Snippets and Libraries Courses Online

Live Instructor Led Online Training Snippets and Libraries courses is delivered using an interactive remote desktop! .

During the course each participant will be able to perform Snippets and Libraries exercises on their remote desktop provided by Qwikcourse.


How do I start learning Snippets and Libraries?


Select among the courses listed in the category that really interests you.

If you are interested in learning the course under this category, click the "Book" button and purchase the course. Select your preferred schedule at least 5 days ahead. You will receive an email confirmation and we will communicate with trainer of your selected course.

Snippets and Libraries Training


Loguru

About

Loguru is a library which aims to bring enjoyable logging in Python. Did you ever feel lazy about configuring a logger and used print() instead?... I did, yet logging is fundamental to every application and eases the process of debugging. Using Loguru you have no excuse not to use logging from the start, this is as simple as from loguru import logger. Also, this library is intended to make Python logging less painful by adding a bunch of useful functionalities that solve caveats of the standard loggers. Using logs in your application should be an automatism, Loguru tries to make it both pleasant and powerful.


7 hours

1,656 €

Coconut

About

Coconut

Coconut (coconut-lang.org) is a variant of Python_ that adds on top of Python syntax new features for simple, elegant, Pythonic functional programming. _ Coconut Coconut is developed on GitHub and hosted on PyPI. Installing Coconut is as easy as opening a command prompt and entering:: pip install coconut after which the entire world of Coconut will be at your disposal. To help you get started, check out these links for more information about Coconut: Credits +++++++ Contributors This project exists thanks to all the people who contribute! Become a contributor. Contributor Backers Thank you to all our backers! Become a backer. Backer Sponsors Support Coconut by becoming a sponsor. Your logo will show up here with a link to your website. Become a sponsor. _ Sponsor


7 hours

1,656 €

Simulator Remote Notifications

About

SimulatorRemoteNotifications

SimulatorRemoteNotifications is a library to send mock remote notifications to the iOS simulator. The library extends UIApplication by embedding a mini server that listen for UDP packets containing JSON-formated payload, and a service to send notifications to the mini server. This project includes the iOS Simulator Notifications MacOSX app to help you send the mock notifications. Note that SimulatorRemoteNotifications does not send notification through Apple's Push Service.


7 hours

1,656 €

Prospector

About

prospector

About Prospector is a tool to analyse Python code and output information about errors, potential problems, convention violations and complexity. It brings together the functionality of other Python analysis tools such as Pylint, pep8, and McCabe complexity


7 hours

1,656 €

LazyList

About

LazyList

A simple library to display images in Android ListView. Images are being downloaded asynchronously in the background. Images are being cached on SD card and in memory. Can also be used for GridView and just to display images into an ImageView. Originally published here.

Basic Usage

ImageLoader imageLoader=new ImageLoader(context); imageLoader.DisplayImage(url, imageView); Don't forget to add the following permissions to your AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET"/>

 

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

Please create only one instance of ImageLoader and reuse it all around your application. This way image caching will be much more efficient.


7 hours

1,656 €

Jnativehook

About

JNativeHook is a library to provide global keyboard and mouse listeners for Java. This will allow you to listen for global shortcuts or mouse motion that would otherwise be impossible using pure Java. To accomplish this task, JNativeHook leverages platform-dependent native code through Java's native interface to create low-level system-wide hooks and deliver those events to your application. The following events are available via their respective listeners.

  • Key Press Events
  • Key Release Events
  • Key Typed Events
  • Mouse Down Events
  • Mouse Up Events
  • Mouse Click Events
  • Mouse Move Events
  • Mouse Drag Events
  • Mouse Wheel Events In addition to global event listners, this library has the ability to post native events back to the native operating system.

7 hours

1,656 €

Matplotlib 3.0

About

matplotlib is plotting library, It is a free software. matplotlib is developed by John D. HunterSupported by cross-platform Operating Systems.

7 hours

1,656 €

Firmware Analysis Toolkit

About

Firmware Analysis Toolkit

FAT is a toolkit built in order to help security researchers analyze and identify vulnerabilities in IoT and embedded device firmware. This is built in order to use for the "Offensive IoT Exploitation" training conducted by Attify. Note:

  • As of now, it is simply a script to automate Firmadyne which is a tool used for firmware emulation. In case of any issues with the actual emulation, please post your issues in the firmadyne issues.  
  • In case you are facing issues, you can try AttifyOS which has Firmware analysis toolkit and other tools pre-installed and ready to use. Firmware Analysis Toolkit (FAT henceforth) is based on Firmadyne with some changes. Firmadyne uses a PostgreSQL database to store information about the emulated images. However just for the core functionality i.e. emulating firmware, PostgreSQL is not really needed. Hence FAT doesn't use it.

7 hours

1,656 €

Gputil

About

GPUtil

GPUtil is a Python module for getting the GPU status from NVIDA GPUs using nvidia-smi. GPUtil locates all GPUs on the computer, determines their availablity and returns a ordered list of available GPUs. Availablity is based upon the current memory consumption and load of each GPU. The module is written with GPU selection for Deep Learning in mind, but it is not task/library specific and it can be applied to any task, where it may be useful to identify available GPUs. Table of Contents

  1. Requirements
  2. Installation
  3. Usage
    1. Main functions
    2. Helper functions
  4. Examples
    1. Select first available GPU in Caffe
    2. Occupy only 1 GPU in TensorFlow
    3. Monitor GPU in a separate thread
  5. License

    Requirements

    NVIDIA GPU with latest NVIDIA driver installed. GPUtil uses the program nvidia-smi to get the GPU status of all available NVIDIA GPUs. nvidia-smi should be installed automatically, when you install your NVIDIA driver. Supports both Python 2.X and 3.X. Python libraries:

    • subprocess (The Python Standard Library)
    • distutils (The Python Standard Library)
    • math (The Python Standard Library)
    • random (The Python Standard Library)
    • time (The Python Standard Library)
    • os (The Python Standard Library)
    • sys (The Python Standard Library)
    • platform (The Python Standard Library) Tested on CUDA driver version 390.77 Python 2.7 and 3.5.

7 hours

1,656 €

UAObfuscatedString

About

UAObfuscatedString

UAObfuscatedString is a simple and lightweight category of NSMutableString that allows you to prevent sensitive strings from appearing in your compiled binary. Without some sort of obfuscation, strings like backend API methods and urls, API keys and other sensitive data can be extracted by utilizing various command-line tools such as strings.


7 hours

1,656 €

BreezySLAM

About

BreezySLAM

this course contains everything you need to start working with Lidar SLAM in Python. (There is also support for Matlab, C++, and Java; however, because of the popularity of Python for this kind of work, I am no longer updating the code for those languages.) BreezySLAM works with Python 3 on Linux and Mac OS X, and with C++ on Linux and Windows. By using Python C extensions, we were able to get the Python and Matlab versions to run as fast as C++. For maximum efficiency on 32-bit platforms, we use Streaming SIMD extensions (Intel) and NEON (ARMv7) in the compute-intensive part of the code.

BreezySLAM was inspired by the Breezy approach to Graphical User Interfaces developed by my colleague Ken Lambert: an object-oriented Application Programming Interface that is simple enough for beginners to use, but that is efficient enough to scale-up to real world problems; for example, the mapping of an entire floor of a house, shown in the image above-right, made by a BreezySLAM user. As shown in the following code fragment, the basic API is extremely simple: a constructor that accepts Lidar parameters and the size of the map (pixels) and mapping area (meters); a method for updating with the current scan; a method that returns the current robot position; and a method for retrieving the current map as a byte array.


7 hours

1,656 €

Primesieve

About

primesieve

primesieve is a program and C/C++ library that generates primes using a highly optimized implementation. It counts the primes below 10^10 in just 0.4 seconds on an Intel Core i7-6700 CPU (4 x 3.4 GHz). primesieve can generate primes and

  • Release notes
  • Downloads
  • API documentation

    Algorithms

    primesieve generates primes using the segmented sieve of Eratosthenes with This algorithm has a run time complexity of operations and uses memory. Furthermore primesieve uses the algorithm which improves the cache efficiency when generating primes > 2^32. primesieve uses 8 bytes per sieving prime, hence its memory usage is about bytes per thread.

  • More algorithm details

7 hours

1,656 €

Tangram Es

About

Tangram ES

Tangram ES is a C++ library for rendering 2D and 3D maps from vector data using OpenGL ES. It is a counterpart to Tangram. this course contains both the core rendering library and sample applications that use the library on Android, iOS, Mac OS X, Ubuntu, and Raspberry Pi.


7 hours

1,656 €

Robintrack

About

Robintrack

Robintrack is a tool for viewing data about the popularity of various stocks on the Robinhood brokerage. It allows users to view information about which are the most (and least) popular stocks held by its users and view trends over time. When combined with price history and other forms of data, this can be a useful tool for analyzing market sentiment.

Components

Scraper

The scraper periodically scrapes the Robinhood API to pull popularity and price data for all of the stocks that it offers. A server/worker model is used, with RabbitMQ being used a work queue. Once scraped, the data is stored in MongoDB.

Backend

The backend is a Rails application that mainly serves as a shim to the MongoDB database. It serves the API used by the frontend.

Frontend

The frontend is a single-page React application that provides users with access to the site's data via data tables and visualizations.

Installation

You'll need a MongoDB instance running and a RabbitMQ instance for the scraper. Configuration for the backend is handled via environment variables; the MONGO_HOST and MONGO_PORT variables are read at runtime. The scraper takes the same environment variables for MongoDB and everything else via command line arguments. Use the --help flag for both the master and worker scripts to view available config options.

There also must be a Redis instance accessible to the instance with an address defined in the REDIS_HOST environment variable. This is used for caching API requests that do not change between runes of the scraper.


7 hours

1,656 €

FKit

About

FKit (pronounced eff-kit) is a functional programming toolkit for JavaScript. It provides many functions for solving common problems with functions, objects, arrays, and strings. It aims to provide reusable building blocks while maintaining a laser focus on everyday utility. Features:

  • Why reinvent the wheel? FKit provides many functions for solving everyday problems to do with functions, arrays, objects, and strings.
  • FKit treats both strings and arrays as lists, which means you can apply the same list functions to both strings and arrays (e.g. head, tail, map, filter, fold, etc).
  • Most FKit functions are already wherever you need to.

7 hours

1,656 €

Smart App Rate

About

Smart App Rate

Smart app rate dialog for Android which takes user rating into consideration. If the user rates the app below the defined threshold rating, the dialog will change into a feedback form. Otherwise, It will take the user to the Google PlayStore.

Features

If you want the dialog to appear on the Nth session of the app, just add the session(N) to the dialog builder method and move the code to the onCreate() method of your Activity class. The dialog will appear when the app is opened for the Nth time.


7 hours

1,656 €

Dentaku

About

Dentaku

DESCRIPTION Dentaku is a parser and evaluator for a mathematical and logical formula language that allows run-time binding of values to variables referenced in the formulas. It is intended to safely evaluate untrusted expressions without opening security holes. EXAMPLE This is probably simplest to illustrate in code: calculator = Dentaku::Calculator.new calculator.evaluate('10 * 2')

=> 20

Okay, not terribly exciting. But what if you want to have a reference to a variable, and evaluate it at run-time? Here's how that would look: calculator.evaluate('kiwi + 5', kiwi: 2)

=> 7

To enter a case sensitive mode, just pass an option to the calculator instance: calculator.evaluate('Kiwi + 5', Kiwi: -2, kiwi: 2)

=> 7

calculator = Dentaku::Calculator.new(case_sensitive: true) calculator.evaluate('Kiwi + 5', Kiwi: -2, kiwi: 2)

=> 3

You can also store the variable values in the calculator's memory and then evaluate expressions against those stored values: calculator.store(peaches: 15) calculator.evaluate('peaches - 5')

=> 10

calculator.evaluate('peaches >= 15')

=> true

For maximum CS geekery, bind is an alias of store. Dentaku understands precedence order and using parentheses to group expressions to ensure proper evaluation: calculator.evaluate('5 + 3 * 2')

=> 11

calculator.evaluate('(5 + 3) * 2')

=> 16

The evaluate method will return nil if there is an error in the formula. If this is not the desired behavior, use evaluate!, which will raise an exception. calculator.evaluate('10 * x')

=> nil

calculator.evaluate!('10 * x') Dentaku::UnboundVariableError: Dentaku::UnboundVariableError Dentaku has built-in functions (including if, not, min, max, sum, and round) and the ability to define custom functions (see below). Functions generally work like their counterparts in Excel: calculator.evaluate('SUM(1, 1, 2, 3, 5, 8)')

=> 20

calculator.evaluate('if (pears < 10, 10, 20)', pears: 5)

=> 10

calculator.evaluate('if (pears < 10, 10, 20)', pears: 15)

=> 20

round can be called with or without the number of decimal places: calculator.evaluate('round(8.2)')

=> 8

calculator.evaluate('round(8.2759, 2)')

=> 8.28

round follows rounding rules, while roundup and rounddown are ceil and floor, respectively. If you're too lazy to be building calculator objects, there's a shortcut just for you: Dentaku('plums * 1.5', plums: 2)

=> 3.0

PERFORMANCE The flexibility and safety of Dentaku don't come without a price. Tokenizing a string, parsing to an AST, and then evaluating that AST are about 2 orders of magnitude slower than doing the same math in pure Ruby! The good news is that most of the time is spent in the tokenization and parsing phases, so if performance is a concern, you can enable AST caching: Dentaku.enable_ast_cache! After this, Dentaku will cache the AST of each formula that it evaluates, so subsequent evaluations (even with different values for variables) will be much faster -- closer to 4x native Ruby speed. As usual, these benchmarks should be considered rough estimates, and you should measure with representative formulas from your application. Also, if new formulas are constantly introduced to your application, AST caching will consume more memory with each new formula. BUILT-IN OPERATORS AND FUNCTIONS Math: +, -, *, /, %, ^, |, & Also, all functions from Ruby's Math module, including SIN, COS, TAN, etc. Comparison: , `=`,, !=, =, Logic: IF, AND, OR, NOT, SWITCH Numeric: MIN, MAX, SUM, AVG, COUNT, ROUND, ROUNDDOWN, ROUNDUP Selections: CASE (syntax see spec) String: LEFT, RIGHT, MID, LEN, FIND, SUBSTITUTE, CONCAT, CONTAINS RESOLVING DEPENDENCIES If your formulas rely on one another, they may need to be resolved in a particular order. For example: calc = Dentaku::Calculator.new calc.store(monthly_income: 50) need_to_compute = { income_taxes: "annual_income / 5", annual_income: "monthly_income * 12" } In the example, annual_income needs to be computed (and stored) before income_taxes. Dentaku provides two methods to help resolve formulas in order:

Calculator.dependencies

Pass a (string) expression to Dependencies and get back a list of variables (as :symbols) that are required for the expression. Dependencies also takes into account variables already (explicitly) stored into the calculator. calc.dependencies("monthly_income * 12")

=> []

(since monthly_income is in memory)

calc.dependencies("annual_income / 5")

=> [:annual_income]

Calculator.solve! / Calculator.solve

Have Dentaku figure out the order in which your formulas need to be evaluated. Pass in a hash of {eventual_variable_name: "expression"} to solve! and have Dentaku resolve dependencies (using TSort) for you. Raises TSort::Cyclic when a valid expression order cannot be found. calc = Dentaku::Calculator.new calc.store(monthly_income: 50) need_to_compute = { income_taxes: "annual_income / 5", annual_income: "monthly_income * 12" } calc.solve!(need_to_compute)

=> {annual_income: 600, income_taxes: 120}

calc.solve!( make_money: "have_money", have_money: "make_money" }

=> raises TSort::Cyclic

solve! will also raise an exception if any of the formulas in the set cannot be evaluated (e.g. raise ZeroDivisionError). The non-bang solve method will find as many solutions as possible and return the symbol :undefined for the problem formulas. INLINE COMMENTS If your expressions grow long or complex, you may add inline comments for future reference. This is particularly useful if you save your expressions in a model. calculator.evaluate('kiwi + 5 / This is a comment /', kiwi: 2)

=> 7

Comments can be single or multi-line. The following are also valid. /*

  • This is a multi-line comment / / This is another type of multi-line comment */ EXTERNAL FUNCTIONS I don't know everything, so I might not have implemented all the functions you need. Please implement your favorites and send a pull request! Okay, so maybe that's not feasible because:
    1. You can't be bothered to share
    2. You can't wait for me to respond to a pull request, you need it NOW()
    3. The formula is the secret sauce for your startup Whatever your reasons, Dentaku supports adding functions at runtime. To add a function, you'll need to specify a name, a return type, and a lambda that accepts all function arguments and returns the result value. Here's an example of adding a function named POW that implements exponentiation.

      c = Dentaku::Calculator.new c.add_function(:pow, :numeric, ->(mantissa, exponent) { mantissa ** exponent }) c.evaluate('POW(3,2)')

      => 9

      c.evaluate('POW(2,3)')

      => 8

      Here's an example of adding a variadic function: c = Dentaku::Calculator.new c.add_function(:max, :numeric, ->(*args) { args.max }) c.evaluate 'MAX(8,6,7,5,3,0,9)'

      => 9

      (However both of these are already built-in -- the ^ operator and the MAX function) Functions can be added individually using Calculator#add_function, or en masse


7 hours

1,656 €

CrypTen

About

CrypTen is a framework for Privacy Preserving Machine Learning built on PyTorch. Its goal is to make secure computing techniques accessible to Machine Learning practitioners. It currently implements Secure Multiparty Computation as its secure computing backend and offers three main benefits to ML researchers:

  1. It is machine learning first. The framework presents the protocols via a CrypTensor object that looks and feels exactly like a PyTorch Tensor. This allows the user to use automatic differentiation and neural network modules akin to those in PyTorch.
  2. CrypTen is library-based. It implements a tensor library just as PyTorch does. This makes it easier for practitioners to debug, experiment on, and explore ML models.
  3. The framework is built with real-world challenges in mind. CrypTen does not scale back or oversimplify the implementation of the secure protocols. Here is a bit of CrypTen code that encrypts and decrypts tensors and adds them import torch import crypten crypten.init() x = torch.tensor([1.0, 2.0, 3.0]) x_enc = crypten.cryptensor(x) # encrypt x_dec = x_enc.get_plain_text() # decrypt y_enc = crypten.cryptensor([2.0, 3.0, 4.0]) sum_xy = x_enc + y_enc # add encrypted tensors sum_xy_dec = sum_xy.get_plain_text() # decrypt sum It is currently not production ready and its main use is as a research framework.

7 hours

1,656 €

Asynchbase

About

Asynchronous HBase

This is an alternative Java library to use HBase in applications that require a fully asynchronous, non-blocking, thread-safe, high-performance HBase API. This HBase client differs significantly from HBase's client (HTable). Switching to it is not easy as it requires to rewrite all the code that was interacting with any HBase API. This pays off in applications that are asynchronous by nature or that want to use several threads to interact efficiently with HBase.


7 hours

1,656 €

Jest Fetch Mock

About

Jest Fetch Mock

Fetch is the canonical way to do HTTP requests in the browser, and it can be used in other environments such as React Native. Jest Fetch Mock allows you to easily mock your fetch calls and return the response you need to fake the HTTP requests. It's easy to setup and you don't need a library like nock to get going and it uses Jest's built-in support for mocking under the surface. This means that any of the jest.fn() methods are also available. For more information on the jest mock API, check their docs here It currently supports the mocking with the cross-fetch polyfill, so it supports Node.js and any browser-like runtime.

Contents


7 hours

1,656 €

Mutation Summary

About

What is this?

Mutation Summary is a JavaScript library that makes observing changes to the DOM fast, easy and safe. It's built on top of (and requires) a new browser API called DOM Mutation Observers.

  • Browsers which currently implement DOM Mutation Observers.
  • DOM Mutation Observers API and its relationship to this library and (the deprecated) DOM Mutation Events.

Why do I need it?

Mutation Summary does five main things for you:

  • It tells you how the document is different now from how it was. As its name suggests, it summarizes whats happened. Its as if it takes a picture of the document when you first create it, and then again after each time it calls you back. When things have changed, it calls you with a concise description of exactly whats different now from the last picture it took for you.
  • It handles any and all changes, no matter how complex. All kinds of things can happen to the DOM: values can change and but put back to what they were, large parts can be pulled out, changed, rearranged, put back. Mutation Summary can take any crazy thing you throw at it. Go ahead, tear the document to shreds, Mutation Summary wont even blink.
  • It lets you express what kinds of things youre interested in. It presents a query API that lets you tell it exactly what kinds of changes youre interested in. This includes support for simple CSS-like selector descriptions of elements you care about.
  • Its fast. The time and memory it takes is dependant on number of changes that occurred (which typically involves only a few nodes) -- not the size of your document (which is commonly thousands of nodes).
  • It can automatically ignore changes you make during your callback. Mutation Summary is going to call you back when changes have occurred. If you need to react to those changes by making more changes -- wont you hear about those changes the next time it calls you back? Not unless you ask for that. By default, it stops watching the document immediately before it calls you back and resumes watching as soon as your callback finishes.

    What is it useful for?

    Lots of things, here are some examples:

  • Browser extensions. Want to make a browser extension that creates a link to your mapping application whenever an address appears in a page? you'll need to know when those addresses appear (and disappear).
  • Implement missing HTML capabilities. Think building web apps is too darn hard and you know whats missing from HTML that would make it a snap? Writing the code for the desired behavior is only half the battle--you'll also need to know when those elements and attributes show up and what happens to them. In fact, theres already two widely used classes of libraries which do exactly this, but dont currently have a good way to observe changes to the DOM.
    • UI Widget libraries, e.g. Dojo Widgets
    • Templating and/or Databinding libraries, e.g. Angular or KnockoutJS
  • Text Editors. HTML Text editors often want to observe whats being input and fix it up so that they can maintain a consistent WYSWIG UI.

    What is this not useful for?

    The intent here isn't to be all things to all use-cases. Mutation Summary is not meant to:

  • Use the DOM as some sort of state-transition machine. It won't report transient states that the DOM moved through. It will only tell you what the difference is between the previous state and the present one.
  • Observing complex selectors. It offers support for a simple subset of CSS selectors. Want to observe all elements that match div[foo] span.bar > p:first-child? Unfortunately, efficiently computing that is much harder and currently outside the scope of this library. Note that both of the above use cases are possible given the data that the underlying Mutation Observers API provides -- we simply judged them to be outside the "80% use case" that we targeted with this particular library.

    Where can Mutation Summary be used?

    The Mutation Summary library depends on the presence of the Mutation Observer DOM API. Mutation Observers are available in

    • Google Chrome
    • Firefox
    • Safari
    • Opera
    • IE11 Mutation Observers is the work of the W3C WebApps working group. In the future it will be implemented in other browsers (well keep the above list of supporting browsers as up-to-date as possible).

      Great. I want to get started. Whats next?

  • Check out the tutorial and the API reference.

    Google groups discussion list.


7 hours

1,656 €

Insetter

About

Insetter

Insetter is a library to help apps handle The library contains implementations of many of the concepts described in our blog post. There are a number of libraries available:

insetter

The base library which is written in Java, and provides an easy-to-use instances: Insetter.builder() // This will apply the system window insets as padding to left, bottom and right of the view, // maintaining the original padding (from the layout XML, style, etc) .applySystemWindowInsetsToPadding(Side.LEFT | Side.BOTTOM | Side.RIGHT) // This is a shortcut for view.setOnApplyWindowInsetsListener(builder.build()) .applyToView(view);

insetter-ktx

A Kotlin extension library, providing Kotlin-specific functionality. This library contains extension functions allowing easy access to the helper functions from the base library: bottomNav.applySystemWindowInsetsToPadding(bottom = true) btnConfirm.applySystemWindowInsetsToMargin(bottom = true, right = true) A [Data Binding][databinding] extension library, providing [Data Binding][databinding] specific functionality. This primarily contains binding adapters, which allow access to the helper functions from your layouts:

You can read more information here. An extension library which provides versions of commonly used ViewGroups with enhanced inset handling. Currently this library is focusing on building upon A example of a widget is InsetterConstraintLayout, which enables new attributes to define inset behavior on child views. The behavior enabled through InsetterConstraintLayout is similar to that provided by the insetter-dbx library, but without the requirement of using data-binding.

You can read more information here.

Attention

The library is being written to production quality, but it is not adhering to semantic versioning, mean we may change the API if needed, though we'll try not to. We're using this course to allow quick and easy prototyping. 


7 hours

1,656 €

Peepdf

About

peepdf is a Python tool to explore PDF files in order to find out if the file can be harmful or not. The aim of this tool is to provide all the necessary components that a security researcher could need in a PDF analysis without using 3 or 4 tools to make all the tasks. With peepdf it's possible to see all the objects in the document showing the suspicious elements, supports all the most used filters and encodings, it can parse different versions of a file, object streams and encrypted files. With the installation of PyV8 and Pylibemu it provides Javascript and shellcode analysis wrappers too. Apart of this it's able to create new PDF files and to modify/obfuscate existent ones. The main functionalities of peepdf are the following: Analysis:

  • Decodings: hexadecimal, octal, name objects
  • More used filters
  • References in objects and where an object is referenced
  • Strings search (including streams)
  • Physical structure (offsets)
  • Logical tree structure
  • Metadata
  • Modifications between versions (changelog)
  • Compressed objects (object streams)
  • Analysis and modification of Javascript (PyV8): unescape, replace, join
  • Shellcode analysis (Libemu python wrapper, pylibemu)
  • Variables (set command)
  • Extraction of old versions of the document
  • Easy extraction of objects, Javascript code, shellcodes (>, >>, $>, $>>)
  • Checking hashes on VirusTotal Creation/Modification:
  • Basic PDF creation
  • Creation of PDF with Javascript executed wen the document is opened
  • Creation of object streams to compress objects
  • Embedded PDFs
  • Strings and names obfuscation
  • Malformed PDF output: without endobj, garbage in the header, bad header...
  • Filters modification
  • Objects modification Execution modes:
  • Simple command line execution
  • Powerful interactive console (colorized or not)
  • Batch mode TODO:
  • Embedded PDFs analysis
  • Improving automatic Javascript analysis
  • GUI Related articles:
  • Spammed CVE-2013-2729 PDF exploit dropping ZeuS-P2P/Gameover
  • New peepdf v0.2 (Version Black Hat Vegas 2012)
  • peepdf supports CCITTFaxDecode encoded streams
  • Explanation of the changelog of peepdf for Black Hat Europe Arsenal 2012
  • How to extract streams and shellcodes from a PDF, the easy way
  • Static analysis of a CVE-2011-2462 PDF exploit
  • Analysis of a malicious PDF from a SEO Sploit Pack
  • Analysing the Honeynet Project challenge PDF file with peepdf Part 1 Part 2
  • Analyzing Suspicious PDF Files With Peepdf Included in:
  • REMnux
  • BackTrack 5
  • Kali Linux You are free to contribute with feedback, bugs, patches, etc. Any help is welcome. 

7 hours

1,656 €

Served

About

Served

Overview

Served is a C++ library for building high performance RESTful web servers. Served builds upon Boost.ASIO to provide a simple API for developers to create HTTP services in C++. Features:

  • [x] HTTP 1.1 compatible request parser
  • [x] Middleware / plug-ins
  • [x] Flexible handler API
  • [x] Cross-platform compatible

7 hours

1,656 €

Telemetry

About

Telemetry

Telemetry is a dynamic dispatching library for metrics and instrumentations. It is lightweight, small and can be used in any Erlang or Elixir project. In a nutshell, you register a custom module and function to be invoked for certain events, which are executed whenever there is such event. Event name is a list of atoms. Each event is composed of a numeric value and can have metadata attached to it. Let's see an example. Imagine that you have a web application and you'd like to log latency and response status for each incoming request. With Telemetry, you can build a module which does exactly that whenever a response is sent. The first step is to execute a measurement. In Elixir: :telemetry.execute( %{latency: latency}, %{request_path: path, status_code: status} ) In Erlang: telemetry:execute(

{latency => Latency},

{request_path => Path, status_code => Status}

) Then you can create a module to be invoked whenever the event happens. In Elixir: defmodule LogResponseHandler do require Logger def handle_event([:web, :request, :done], measurements, metadata, _config) do Logger.info("[#{metadata.request_path}] #{metadata.status_code} sent in #{measurements.latency}") end end In Erlang: handle_event([web, request, done], #{latency := Latency}, #{request_path := Path, status_code := Status}, _Config) -> ?LOG_INFO("[~s] ~p sent in ~p", [Path, Status, Latency]). Important note: The handle_event callback of each handler is invoked synchronously on each telemetry:execute call. Therefore, it is extremely important to avoid blocking operations. If you need to perform any action that it is not immediate, consider offloading the work to a separate process (or a pool of processes) by sending a message. Finally, all you need to do is to attach the module to the executed event. In Elixir: :ok = :telemetry.attach(

unique handler id

"log-response-handler", &LogResponseHandler.handle_event/4, nil ) In Erlang: ok = telemetry:attach( %% unique handler id , fun log_response_handler:handle_event/4, ) You might think that it isn't very useful, because you could just as well write a log statement instead of Telemetry.execute/3 call - and you would be right! But now imagine that each Elixir library would publish its own set of events with information useful for introspection. Currently each library rolls their own instrumentation layer - Telemetry aims to provide a single interface for these use cases across whole ecosystem. In order to provide uniform events that capture the start and end of discrete events, it is recommended that you use the telemetry:span/3 call. This function will generate a start event and a stop or exception event depending on whether the provided function successfully executed or raised and error. Under the hood, the telemetry:span/3 function leverages the telemetry:execute/3 function, so all the same usage patterns apply. If an exception does occur, an EventPrefix ++ [exception] event will be emitted and the caught error will be re-raised. The measurements for the EventPrefix ++ [start] event will contain a key called system_time which is derived by calling erlang:system_time(). For EventPrefix ++ [stop] and EventPrefix ++ [exception] events, the measurements will contain a key called duration, whose value is derived by calling erlang:monotonic_time() - StartMonotonicTime. Both system_time and duration represent time as native units. To create span events, you would do something like so: In Elixir: def process_message(message) do start_metadata = %{message: message} result = :telemetry.span( start_metadata, fn -> result = # Process the message {result, %{metadata: "Information related to the processing of the message"}} end ) end In Erlang: process_message(Message) -> StartMetadata = #{message => Message}, Result = telemetry:span( StartMetadata, fun() -> Result = % Process the message {Result, #{metadata => "Information related to the processing of the message"}} end ). To then attach to the events that telemetry:span/3 emits you would do the following: In Elixir: :ok = :telemetry.attach_many( "log-response-handler", ], &LogResponseHandler.handle_event/4, nil ) In Erlang: ok = telemetry:attach_many( , ], fun log_response_handler:handle_event/4, ) With the following event handler module defined: In Elixir: defmodule LogResponseHandler do require Logger def handle_event(event, measurements, metadata, _config) do Logger.info("Event: #{inspect(event)}") Logger.info("Measurements: #{inspect(measurements)}") Logger.info("Metadata: #{inspect(metadata)}") end end In Erlang: handle_event(Event, Measurements, Metadata, _Config) -> ?LOG_INFO("Event: ~p", [Event]), ?LOG_INFO("Measurements: ~p", [Measurements]), ?LOG_INFO("Metadata: ~p", [Metadata]). See the documentation for more details.


7 hours

1,656 €

Explore DECAF

About

DECAF (Dynamic Executable Code Analysis Framework) is a binary analysis platform based on QEMU.

DECAF++

DECAF++, the new version of DECAF, taint analysis is around 2X faster making it the fastest, to the best of our knowledge, whole-system dynamic taint analysis framework. This results in a much better usability imposing only 4% overhead (SPEC CPU2006) when no suspicious (tainted) input exists. Even under heavy taint analysis workloads, DECAF++ has a much better performance, around 25% faster on nbench, because of its elasticity. DECAF++ elasticity makes it a very suitable case for security analysis tasks that would selectively analyze the input e.g. Intrusion Detection Systems (IDS) that can filter out benign traffic. 


7 hours

1,656 €

Subdomain3

About

Subdomain3 is a new generation of tool , It helps penetration testers to discover more information in a shorter time than other tools.The information includes subdomains, IP, CDN, and so on. Please enjoy it.

Features

  • More quick Three patterns for speed. User can modify the configuration(lib/config.py) file to speed-up.
  • CDN support Determines whether the subdomain uses CDN storage automatically,even though the dict of CDN severs not contain the cname suffix.
  • RFC CIDR Sorting ip and report CIDR(example 1.1.1.1/24) that it not use CDN storage;
  • Multi-level subdomain support Discover more subdomains,example:admin.test.xx.com
  • Big dict support Million of subs support
  • Less resource consumption 1 CPU/1GB Memory/1Mbps bandwidth
  • More intelligent Discover the fastest nameserver;The strategy of dynamically adjusting of dict by importing subdomains from other sources;Prevent dns cache pollution;

7 hours

1,656 €

Mappedbus

About

Mappedbus is a Java based high throughput, low latency message bus, using a memory mapped file or shared memory as transport

Mappedbus was inspired by Java Chronicle with the main difference that it's designed to efficiently support multiple writers enabling use cases where the order of messages produced by multiple processes are important. The throughput (on a laptop, i7-4558U @ 2.8 GHz) between a single producer writing at full speed and a single consumer is around 14 million messages per second (a small message consisting of three integer fields), and the average read/write latency is around 70 ns per message. Mappedbus does not create any objects after startup and therefore has no GC impact.

Features:

  • IPC between multiple processes by message passing
  • Support for a memory mapped file or shared memory as transport
  • Support for object or byte array (raw data) based messages

7 hours

1,656 €

Alcinoe

About

Alcinoe is a library of visual and non-visual components for Delphi. The components can be used in commercial as well as shareware and freeware and open source projects without cost. Alcinoe is compatible with Delphi RIO 10.3.3 Please "star" (like) this project in GitHub! It's cost nothing but help to reference the code Example of an app made with Alcinoe: KisKis

  • YouTube: https://www.youtube.com/watch?v=IJzEuZTSXDI&vq=hd2160
  • iOS: https://itunes.apple.com/us/app/id1420049759
  • Android: https://play.google.com/store/apps/details?id=club.kiskis.app&hl=en Compiled demo

    Win32

  • https://svn.code.sf.net/p/alcinoe/code/demos/ALWinHTTPClient/win32/ALWinHTTPClientDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALWinInetHTTPClient/win32/ALWinInetHTTPClientDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALSortedListBenchmark/win32/ALSortedListBenchmark.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALCipherDemo/win32/ALCipherDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALJsonDoc/win32/AljsonDocDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALNNTPClient/win32/ALNNTPClientDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALPhpRunner/win32/ALPhpRunnerDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALPOP3Client/win32/POP3ClientDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALSMTPClient/win32/ALSMTPClientDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALSqlite3Client/win32/ALSqlite3clientDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALStressHTTPServer/win32/ALStressHTTPServer.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALStringBenchmark/win32/ALStringBenchmark.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALWebSpider/win32/ALWebSpiderDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALXmlDoc/win32/AlXmlDocDemo.exe
  • https://svn.code.sf.net/p/alcinoe/code/demos/ALLiveVideoChat/server/Win32/Release/ALLiveVideoChatServer.exe

    Android

  • https://tinyurl.com/zoxavr9 (ALFmxControl.apk)
  • https://tinyurl.com/yd7c4ofk (ALFirebaseMessagingDemo.apk)
  • https://tinyurl.com/y9gzos9f (ALFacebookLogin.apk)
  • https://tinyurl.com/yaft2wxr (ALFmxEffects.apk)
  • https://tinyurl.com/ydymo23w (ALLiveVideoChatClient.apk)

    iOS

    Please ask apple how to do


7 hours

1,656 €

OpenKB

About

openKB

openKB is a Markdown Knowledge base application (FAQ) built with Nodejs and ExpressJS. The application uses an embedded database (nedb) by default but can also use a MongoDB server by changing the config (see below). The application is designed to be easy to use and install and based around search rather than nested categories. Simply search for what you want and select from the results.


7 hours

1,656 €

Reflex Platform

About

Reflex Platform

reflex-platform is a curated package set and set of tools that let you build Haskell packages so they can run on a variety of platforms. reflex-platform is built on top of the nix package manager. There are five main reasons to use reflex-platform:

  1. It's curated: the core packages in reflex-platform are known to work together and are tested together.
  2. It's cached: the core packages in reflex-platform are cached so you can download prebuilt binaries from the public cache instead of building from scratch.
  3. It's consistent: nix locks down dependencies even outside the Haskell ecosystem (e.g., versions of C libraries that the Haskell code depends on), so you get completely reproducible builds.
  4. It's cross-platform: reflex-platform is designed to target iOS and Android on mobile, JavaScript on the web, and Linux and macOS on desktop. It's Haskell, everywhere.
  5. It's convenient: reflex-platform comes packaged with tools to make development easier, like a hoogle server that you can run locally to look up definitions. To get started with Reflex development, follow the instructions below. Try Reflex lets you set up an environment from which you can use Reflex with GHC or GHCJS.

7 hours

1,656 €

Uitable

About

uitable

uitable is a go library for representing data as tables for terminal applications. It provides primitives for sizing and wrapping columns to improve readability.

Example Usage

Full source code for the example is available at example/main.go table := uitable.New() table.MaxColWidth = 50 table.AddRow("NAME", "BIRTHDAY", "BIO") for , hacker := range hackers { table.AddRow(hacker.Name, hacker.Birthday, hacker.Bio) } fmt.Println(table) Will render the data as: NAME BIRTHDAY BIO Ada Lovelace December 10, 1815 Ada was a British mathematician and writer, chi... Alan Turing June 23, 1912 Alan was a British pioneering computer scientis... For wrapping in two columns: table = uitable.New() table.MaxColWidth = 80 table.Wrap = true // wrap columns for , hacker := range hackers { table.AddRow("Name:", hacker.Name) table.AddRow("Birthday:", hacker.Birthday) table.AddRow("Bio:", hacker.Bio) table.AddRow("") // blank } fmt.Println(table) Will render the data as: Name: Ada Lovelace Birthday: December 10, 1815 Bio: Ada was a British mathematician and writer, chiefly known for her work on Charles Babbage's early mechanical general-purpose computer, the Analytical Engine Name: Alan Turing Birthday: June 23, 1912 Bio: Alan was a British pioneering computer scientist, mathematician, logician, cryptanalyst and theoretical biologist


7 hours

1,656 €

Module Server

About

Module Server

Module server is a system for efficient serving of CommonJS modules to web browsers. The core feature is that it supports incremental loading of modules and their dependencies with exactly 1 HTTP request per incremental load. This is a reference implementation that has not been battle-tested in production use. See our presentation from JSConf EU 2012 for more details. The serving system implements the following constraints: For many web applications serving all JavaScript in a single compiled binary may be a good enough, simple solution, more complex apps with large JS code bases will profit from only downloading code when it is needed. While AMD loaders such as require.js implement incremental loading as well, they often do so through recursive downloading of dependencies which may significantly degrade latency. Closure compiler supports both compilation of CommonJS and AMD modules. It should thus be possible to use this system as a production frontend for projects that use other systems such as require.js or browserify today.

Source Maps

By default all JS responses support source maps for optimal debugging with Chrome Dev Tools (Don't forget to activate source map support in the Dev Tools settings). We recommend to deactivate this for production use, if you only want to provide clients access to obfuscated JS


7 hours

1,656 €

ORSSerialPort

About

ORSSerialPort

ORSSerialPort is an easy-to-use Objective-C serial port library for macOS. It is useful for programmers writing Objective-C or Swift Mac apps that communicate with external devices through a serial port (most commonly RS-232). You can use ORSSerialPort to write apps that connect to Arduino projects, robots, data acquisition devices, ham radios, and all kinds of other devices. Using ORSSerialPort to open a port and send data can be as simple as this: let serialPort = ORSSerialPort(path: "/dev/cu.KeySerial1") serialPort.baudRate = 4800 serialPort.open() serialPort.send(someData) // someData is an NSData object serialPort.close() // Later, when you're done with the port Or, in Objective-C: ORSSerialPort *serialPort = [ORSSerialPort serialPortWithPath:@"/dev/cu.KeySerial1"]; serialPort.baudRate = @4800;

ORSSerialPort is released under an MIT license, meaning you're free to use it in both closed and open source projects. However, even in a closed source project, you must include a publicly-accessible copy of ORSSerialPort's copyright notice, which you can find in the LICENSE file. If you have any questions about, suggestions for, or contributions to ORSSerialPort, please contact me. I'd also love to hear about any cool projects you're using it in. This readme provides an overview of the ORSSerialPort library and is meant to provide enough information to get up and running quickly. You can read complete technical documentation for ORSSerialPort on http://cocoadocs.org/docsets/ORSSerialPort/. The ORSSerialPort wiki also contains detailed documentation. Most of the example code in this readme is in Swift. However, ORSSerialPort can also easily be used from Objective-C code.


7 hours

1,656 €

RxDogTag

About

RxDogTag

RxDogTag is a utility to tag originating subscribe points in RxJava 2+ observers, with the goal of surfacing their subscribe locations for error reporting/investigation later in the event of an unhandled error. This is only for RxJava observers that do not implement onError().


7 hours

1,656 €

Kimera

About

Kimera

Kimera is a C++ library for real-time metric-semantic simultaneous localization and mapping, which uses camera images and inertial data to build a semantically annotated 3D mesh of the environment. Kimera is modular, ROS-enabled, and runs on a CPU. Kimera comprises four modules:

Click on the following links to install Kimera's modules and get started! It is very easy to install!

Chart

Citation

If you found any of the above modules useful, we would really appreciate if you could cite our work:

@InProceedings{Rosinol20icra-Kimera, title = {Kimera: an Open-Source Library for Real-Time Metric-Semantic Localization and Mapping}, author = {Rosinol, Antoni and Abate, Marcus and Chang, Yun and Carlone, Luca}, year = {2020}, booktitle = {IEEE Intl. Conf. on Robotics and Automation (ICRA)}, url = {https://github.com/MIT-SPARK/Kimera}, pdf = {https://arxiv.org/pdf/1910.02490.pdf} }

Acknowledgments

Kimera was partially funded by the DCIST (Distributed and Collaborative Intelligent Systems and Technology) Collaborative Research Alliance.


7 hours

1,656 €

JsPsych

About

jsPsych is a JavaScript library for creating behavioral experiments that run in a web browser. jsPsych provides a framework for defining experiments using a set of flexible plugins that create different kinds of tasks a subject could complete during an experiment. By assembling these different plugins together it is possible to create many different types of experiments.


7 hours

1,656 €

Pyjanitor

About

pyjanitor

pyjanitor is a Python implementation of the R package janitor, and provides a clean API for cleaning data. Why janitor? Originally a port of the R package, pyjanitor has evolved from a set of convenient data cleaning routines into an experiment with the method chaining paradigm. chaining Data preprocessing usually consists of a series of steps that involve transforming raw data into an understandable/usable format. These series of steps need to be run in a certain sequence to achieve success. We take a base data file as the starting point, and perform actions on it, such as removing null/empty rows, replacing them with other values, adding/renaming/removing columns of data, filtering rows and others. More formally, these steps along with their relationships and dependencies are commonly referred to as a Directed Acyclic Graph (DAG). The pandas API has been invaluable for the Python data science ecosystem, and implements method chaining of a subset of methods as part of the API. For example, resetting indexes (.reset_index()), dropping null values (.dropna()), and more, are accomplished via the appropriate pd.DataFrame method calls. Inspired by the ease-of-use and expressiveness of the dplyr package of the R statistical language ecosystem, we have evolved pyjanitor into a language for expressing the data processing DAG for pandas users. To accomplish this, actions for which we would need to invoke imperative-style statements, can be replaced with method chains that allow one to read off the logical order of actions taken. Let us see the annotated example below. First off, here is the textual description of a data cleaning pathway:

  1. Create a DataFrame.
  2. Delete one column.
  3. Drop rows with empty values in two particular columns.
  4. Rename another two columns.
  5. Add a new column. Let's import some libraries and begin with some sample data for this example :

    Libraries

    import numpy as np import pandas as pd import janitor

    Sample Data curated for this example

    company_sales = { 'SalesMonth': ['Jan', 'Feb', 'Mar', 'April'], 'Company1': [150.0, 200.0, 300.0, 400.0], 'Company2': [180.0, 250.0, np.nan, 500.0], 'Company3': [400.0, 500.0, 600.0, 675.0] } In pandas code, most users might type something like this:

    The Pandas Way

    1. Create a pandas DataFrame from the company_sales dictionary

    df = pd.DataFrame.from_dict(company_sales)

    2. Delete a column from the DataFrame. Say 'Company1'

    del df['Company1']

    3. Drop rows that have empty values in columns 'Company2' and 'Company3'

    df = df.dropna(subset=['Company2', 'Company3'])

    4. Rename 'Company2' to 'Amazon' and 'Company3' to 'Facebook'

    df = df.rename( { 'Company2': 'Amazon', 'Company3': 'Facebook', }, axis=1, )

    5. Let's add some data for another company. Say 'Google'

    df['Google'] = [450.0, 550.0, 800.0]

    Output looks like this:

    Out[15]:

    SalesMonth Amazon Facebook Google

    0 Jan 180.0 400.0 450.0

    1 Feb 250.0 500.0 550.0

    3 April 500.0 675.0 800.0

    Slightly more advanced users might take advantage of the functional API: df = ( pd.DataFrame(company_sales) .drop(columns="Company1") .dropna(subset=['Company2', 'Company3']) .rename(columns={"Company2": "Amazon", "Company3": "Facebook"}) .assign(Google=[450.0, 550.0, 800.0]) )

    Output looks like this:

    Out[15]:

    SalesMonth Amazon Facebook Google

    0 Jan 180.0 400.0 450.0

    1 Feb 250.0 500.0 550.0

    3 April 500.0 675.0 800.0

    With pyjanitor, we enable method chaining with method names that are verbs, which describe the action taken. df = ( pd.DataFrame.from_dict(company_sales) .remove_columns(['Company1']) .dropna(subset=['Company2', 'Company3']) .rename_column('Company2', 'Amazon') .rename_column('Company3', 'Facebook') .add_column('Google', [450.0, 550.0, 800.0]) )

    Output looks like this:

    Out[15]:

    SalesMonth Amazon Facebook Google

    0 Jan 180.0 400.0 450.0

    1 Feb 250.0 500.0 550.0

    3 April 500.0 675.0 800.0

    As such, pyjanitor's etymology has a two-fold relationship to "cleanliness". Firstly, it's about extending Pandas with convenient data cleaning routines. Secondly, it's about providing a cleaner, method-chaining, verb-based API for common pandas routines.


7 hours

1,656 €

Scallop

About

Scallop

A simple command-line arguments parsing library for Scala, written in spirit of Ruby's Trollop. Cross-built for Scala 2.10, 2.11, 2.12, 2.13 and support for Scala Native and Scala JS. Scallop supports:

  • flag, single-value and multiple value options
  • POSIX-style short option names (-a) with grouping (-abc)
  • GNU-style long option names (--opt, --opt=value)
  • unnamed integer options, like GNU tail (-42)
  • Property arguments (-Dkey=value, -D key1=value key2=value)
  • Non-string types of options and properties values (with extendable converters)
  • Powerful matching on trailing args

7 hours

1,656 €

Kin

About

Kin

Kin is a minimalistic tool to check whether your project.pbxproj file is correct. What does it do? Have you ever found yourself undoing a merge due to a broken Xcode build? Then Kin is your tool. It will parse your project configuration file and detect errors.


7 hours

1,656 €

Merchant.js

About

Merchant.js

Merchant is a system for creating programs that manage changing numbers over time. It's especially useful for creating idle games (sometimes called incremental games), but could potentially be used in other games or programs. If you're not sure what an idle game is, click here to find out. Note: If you're trying to be productive right now, that link may not be for you. Merchant works well with Redux, but doesn't require it. Functions return copies and don't modify state. Since Merchant is built on immutable, most of it's key concepts are stored as immutable objects. To be frank, Merchant is really just a collection of patterns with some helpful functions. It's fairly minimalistic but also gives you a good amount of power without sacrificing efficiency.


7 hours

1,656 €

PSWinReporting

About

PSWinReporting

PSWinReporting is a little PowerShell module that solves the problem of monitoring and reading Windows Events. It allows you to set up monitoring of Domain Controllers (and from 2.X any other servers) for events that happen on them. By default, it comes with built-in Active Directory events supports, but since 2.0 you can configure it to monitor anything. You can set up reporting on any types of events and have emails delivered with a summary of hourly, daily, weekly, monthly, or quarterly changes. It also supports sending notifications to Microsoft Teams, Slack, and Discord. Make sure to go thru related articles as they have all the KNOW HOW which is quite useful if you want to get everything from this module. The full project description is available on my website - Full project description. Currently, there are 2 branches of PSWinReporting. I've decided that both PowerShell modules can coexist together, especially for scenarios for people who want to switch, but don't want to do it right away. This way, you can keep using old version as is, and slowly fix your other stuff, or use new Find-Events command. I've slightly renamed the commands for V2 release.

PSWinReportingV2 - Master Edition

Master edition is a complete rewrite and a new beginning. It provides the same functionality as Legacy 1.X version and then some more.

Changelog

At this moment there is no documentation for PSWinReportingV2 except for those articles below. Feel free to explore Examples if you're eager to try the new version otherwise fallback to PSWinReporting Legacy Edition.

Built-in Active Directory Reports

PSWinReporting comes with predefined, built-in reports. Those are for Find-Events. Those also come defined in example configuration script which you can use straight away after verifying everything is as per your requirement.

Built-in Reporting Times

PSWinReporting comes with predefined report times. This means you can use True/False to enable/disable period. In case of Find-Events, you can use defined times (checked only) from DatesRange parameter. Of course, you can also define DateFrom, DateTo parameters for custom use when using Find-Events command.

PSWinReporting - Legacy Edition

Legacy edition will continue it's life as 1.X.X. If you want to keep on using it, feel free, but it's highly encouraged to use 2.x.x when it's fully functional with all features. Code is available as Legacy Branch. Following links can help in understanding how it works and how to set it up: Following AD Events are supported: Features:

Example - Script running

Example - Email Report

Example - Microsoft Teams

Example - Slack


7 hours

1,656 €

Omnisharp Sublime

About

OmnisharpSublime is a plugin for ST3 to provide a C# development environment. It communicates with omnisharp-roslyn by nosami for IDE functions. It works on:

  1. Mac OSX
  2. Linux
  3. Windows

Features

  1. Auto OmniSharpServer running
  2. Asynchronous communication with OmniSharpServer (Never freeze!)
  3. Auto Completion
  4. Goto definition
  5. Rename
  6. Goto implementation
  7. Syntax/Semantic error highlighting
  8. Displays possible override methods
  9. Find Usages
  10. Format Document
  11. Displays code issues such as assigment is redundant
  12. Fix code issues - put cursor on highlighted issue and select Fix Code Issue
  13. Remove Unused, Add Missing and Sort Using Statements
  14. Code Actions eg. Convert LINQ query to Fluent Syntax
  15. Add File To Project
  16. Remove File from Project (via sidebar and context menu)
  17. Add New C# Class & Interface (via sidebar and context menu) via File Templates which also adds to csproj
  18. Type Lookup with Documentation
  19. Hide/Show Info Panel
  20. Reload Solution

    Linux Requirements

    • mono
    • msbuild-stable

Windows Requirements

  • Microsoft Build Tools 2015 (must be added to PATH)

7 hours

1,656 €

Tap

About

TAP.JS

Tap is a Javascript library for easy unified handling of user interactions such as mouse, touch and pointer events.

  • No need to detect what kind of events are supported, Tap handles this for you
  • Small distribution size of 1Kb
  • Use fastest event types supported (majority of browsers has ~300ms delay between touch/pointer events and click). Every millisecond does really matter!

7 hours

1,656 €

Packem

About

Packem

Packem is an extensively precompiled general-purpose JavaScript module bundler with a focus on performance, flexibility and extendibility. Its crust is built with Rust, a zero-cost abstraction systems programming language with guaranteed memory safety.

This is a pre-release version. Do not use it in production.


7 hours

1,656 €

Pixel Saver

About

Pixel Saver

Pixel Saver is an extension for Gnome Shell that merge the activity bar and the title bar of maximized window. It is especially interesting for small screens, but MOAR pixels for your apps is always good! The extension has no configuration. Its behavior is made to mimic the one of the title bar and settings affecting the title bar should reflect in Pixel Saver. It Just Works! For applications using the modern GTK header bar, there are no space savings, but the application title is still displayed in the top panel to achieve a uniform appearance.

The title bar is completely gone and integrated to the activity bar.

It is largely inspired by bios and mathematicalcoffee's Window Buttons Extension and mathematicalcoffee's maximus extension and some code come from there. You may want to check theses out, especially if you want something more configurable. Get it! |---||----| Pixel saver has been available for a long time on (so it is on but it has not been updated there since 2016. New releases are in process of being reviewed (see #177). In the meantime, you can install the extension manually.

Manual install

From graphical interface

.local/share/gnome-shell/extensions;

From terminal

# Clone repository git clone https://github.com/deadalnix/pixel-saver.git # Enter cloned directory cd pixel-saver # Switch to tag 1.20 git checkout tags/1.20 # copy to extensions directory cp -r pixel-saver@deadalnix.me -t ~/.local/share/gnome-shell/extensions # activate gnome-shell-extension-tool -e pixel-saver@deadalnix.me

At last, remember to reload GNOME Shell by pressing Alt + F2 and entering r .

Dependencies

Pixel Saver depends on Xorg's xprop and xwininfo utilities. If not already present on your system, these can be installed using:

  • Debian/Ubuntu: apt install x11-utils
  • Fedora/RHEL: dnf install xorg-x11-utils
  • Arch: pacman -S xorg-xprop Configuration Don't be silly! Screenshots If you want to see what the full desktop look like with this extension, you can check out what a unmaximized window looks like, as well as a maximized one.

7 hours

1,656 €

Etch

About

Etch is a library for writing HTML-based user interface components that provides the convenience of a virtual DOM, while at the same time striving to be minimal, interoperable, and explicit. Etch can be used anywhere, but it was specifically designed with Atom packages and Electron applications in mind.

Overview

Etch components are ordinary JavaScript objects that conform to a minimal interface. Instead of inheriting from a superclass or building your component with a factory method, you access Etch's functionality by passing your component to Etch's library functions at specific points of your component's lifecycle. A typical component is structured as follows: /* @jsx etch.dom / const etch = require('etch') class MyComponent { // Required: Define an ordinary constructor to initialize your component. constructor (props, children) { // perform custom initialization here... // then call etch.initialize: etch.initialize(this) } // Required: The render method returns a virtual DOM tree representing the // current state of the component. Etch will call render to build and update // the component's associated DOM element. Babel is instructed to call the // etch.dom helper in compiled JSX expressions by the @jsx pragma above. render () { return } // Required: Update the component with new properties and children. update (props, children) { // perform custom update logic here... // then call etch.update, which is async and returns a promise return etch.update(this) } // Optional: Destroy the component. Async/await syntax is pretty but optional. async destroy () { // call etch.destroy to remove the element and destroy child components await etch.destroy(this) // then perform custom teardown logic here... } } The component defined above could be used as follows: // build a component instance in a standard way... let component = new MyComponent({foo: 1, bar: 2}) // use the component's associated DOM element however you wish... document.body.appendChild(component.element) // update the component as needed... await component.update({bar: 2}) // destroy the component when done... await component.destroy() Note that using an Etch component does not require a reference to the Etch library. Etch is an implementation detail, and from the outside the component is just an ordinary object with a simple interface and an .element property. You can also take a more declarative approach by embedding Etch components directly within other Etch components, which we'll cover later in this document.

Etch Lifecycle Functions


7 hours

1,656 €

AppAuth JS

About

AppAuth for JavaScript is a client SDK for public clients for communicating with OAuth 2.0 and OpenID Connect providers following the best practice The library is designed for use in Web Apps, Node.js CLI applications, Chrome Apps and applications that use Electron or similar frameworks. It strives to directly map the requests and responses of those specifications, while following the idiomatic style of the implementation language. The library also supports the PKCE extension to OAuth which was created to secure authorization codes in public clients when custom URI scheme redirects are used. The library is friendly to other extensions (standard or otherwise) with the ability to handle additional parameters in all protocol requests and responses.

Examples

An example application using the library is included in the src/node_app folder.

Auth Flow

AppAuth supports manual interaction with the Authorization Server where you need to perform your own token exchanges. This example performs a manual exchange.

Fetch Service Configuration

AuthorizationServiceConfiguration.fetchFromIssuer(openIdConnectUrl) .then(response => { log('Fetched service configuration', response); this.configuration = response; this.showMessage('Completed fetching configuration'); }) .catch(error => { log('Something bad happened', error); this.showMessage(Something bad happened ${error}) });

Make Authorization Requests

this.notifier = new AuthorizationNotifier(); // uses a redirect flow this.authorizationHandler = new RedirectRequestHandler(); // set notifier to deliver responses this.authorizationHandler.setAuthorizationNotifier(this.notifier); // set a listener to listen for authorization responses this.notifier.setAuthorizationListener((request, response, error) => { log('Authorization request complete ', request, response, error); if (response) { this.code = response.code; this.showMessage(Authorization Code ${response.code}); } }); // create a request let request = new AuthorizationRequest({ client_id: clientId, redirect_uri: redirectUri, scope: scope, response_type: AuthorizationRequest.RESPONSE_TYPE_CODE, state: undefined, extras: {'prompt': 'consent', 'access_type': 'offline'} }); // make the authorization request this.authorizationHandler.performAuthorizationRequest(this.configuration, request);

Making Token Requests

this.tokenHandler = new BaseTokenRequestHandler(); let request: TokenRequest|null = null; if (this.code) { let extras: StringMap|undefined = undefined; if (this.request && this.request.internal) { extras = {}; extras['code_verifier'] = this.request.internal['code_verifier']; } // use the code to make the token request. request = new TokenRequest({ client_id: clientId, redirect_uri: redirectUri, grant_type: GRANT_TYPE_AUTHORIZATION_CODE,


7 hours

1,656 €

Typhon

About

Typhon

Typhon is a wrapper around Go's [net/http] library that we use at Monzo to build RPC servers and clients in [our microservices platform][platform blog post]. It provides a number of conveniences and tries to promote safety wherever possible. Here's a short list of interesting features in Typhon:

  • No need to close body.Close() in clients
    Forgetting to body.Close() in a client when the body has been dealt with is a common source of resource leaks in Go programs in our experience. Typhon ensures that unless you're doing something really weird with the body it will be closed automatically.
  • Middleware "filters"
    Filters are decorators around Services; in Typhon servers and clients share common functionality by composing it functionally.
  • Body encoding and decoding
    Marshalling and unmarshalling request bodies to structs is such a common operation that our Request and Response objects support them directly. If the operations fail, the errors are propagated automatically since that's nearly always what a server will want.
  • Propagation of cancellation
    When a server has done handling a request, the request's context is automatically cancelled, and these cancellations are propagated through the distributed call stack. This lets downstream servers conserve work producing responses that are no longer needed.
  • Error propagation
    Responses have an inbuilt Error attribute, and serialisation/deserialisation of these errors into HTTP errors is taken care of automatically. We recommend using this in conjunction with [monzo/terrors].
  • Full HTTP/1.1 and HTTP/2.0 support
    Applications implemented using Typhon can communicate over HTTP/1.1 or HTTP/2.0. Typhon has support for full duplex communication under HTTP/2.0, and [h2c] (HTTP/2.0 over TCP, ie. without TLS) is also supported if required.

7 hours

1,656 €

Tsschecker

About

tsschecker

tsschecker is a powerful tool to check TSS signing status of various devices and iOS/iPadOS/tvOS/watchOS versions. Latest compiled version can be found here: https://github.com/tihmstar/tsschecker/releases. Follow this guide to use tsschecker on Ubuntu 18.04 (Bionic) as it requires libcurl3 which cannot coexist with libcurl4 on this OS.

Features

  • Allows you to get lists of all devices and all iOS/OTA versions for a specific device.
  • Can check signing status for default iOS versions and beta ipsws (by specifying a BuildManifest.plist)
  • Works without specifying any device relevant values to check signing status, but can be used to save blobs when given an ECID and the option --print-tss-response (although there are better tools to do this). tsschecker is not only meant to be used to check firmware signing status, but also to explore Apple's TSS servers. By using all of its customization possibilities, you might discover a combination of devices and iOS versions that is now getting signed but wasn't getting signed before.

    About nonces:

    default generators for saving tickets:

  • 0xbd34a880be0b53f3 // used on Electra & Chimera jailbreaks
  • 0x1111111111111111 // used on unc0ver jailbreak Nonce collision method isn't needed anymore, because we've checkm8 low-level exploit.

    Dependencies

  • Bundled libs

    Those don't need to be installed manually

    • tss
  • External libs

    Make sure these are installed

    • libcurl
    • libplist
    • libfragmentzip
    • openssl or commonCrypto on macOS/OS X;
    • libirecovery;
  • Submodules

    Make sure these projects compile on your system

    • jssy

7 hours

1,656 €

Pyprind

About

PyPrind (Python Progress Indicator)

The PyPrind (Python Progress Indicator) module provides a progress bar and a percentage indicator object that let you track the progress of a loop structure or other iterative computation.

Typical applications include the processing of large data sets to provide an intuitive estimate at runtime about the progress of the computation.

Topics covered in this course include:

  • Progress Bars and Percentage Generators

  • While-loops

  • Advanced Tracking

  • Choose Your Favorite Bar Style


4 hours

946 €

Fusesoc

About

FuseSoC

Introduction FuseSoC is an award-winning package manager and a set of build tools for HDL (Hardware Description Language) code. Its main purpose is to increase reuse of IP (Intellectual Property) cores and be an aid for creating, building and simulating SoC solutions. FuseSoC makes it easier to FuseSoC is non-intrusive Most existing designs doesn't need any changes to work with FuseSoC. Any FuseSoC-specific patches can be applied on the fly during implementation or simulation FuseSoC is modular It can be used as an end-to-end flow, to create initial project files for an EDA tool or integrate with your custom workflow FuseSoC is extendable Latest release support simulating with GHDL, Icarus Verilog, Isim, ModelSim, Verilator and Xsim. It also supports building FPGA images with Altera Quartus, project IceStorm, Xilinx ISE and Xilinx Vivado. Support for a new EDA tool requires ~100 new lines of code and new tools are added continuously FuseSoC is standard-compliant Much effort has gone into leveraging existing standards such as IP-XACT and vendor-specific core formats where applicable. FuseSoC is resourceful The standard core library currently consisting of over 100 cores including CPUs, peripheral controllers, interconnects, complete SoCs and utility libraries. Other core libraries exist as well and can be added to complement the standard library FuseSoC is free software It puts however no restrictions on the cores and can be used to manage your company's internal proprietary core collections as well as public open source projects FuseSoC is battle-proven It has been used to successfully build or simulate projects such as Nyuzi, Pulpino, VScale, various OpenRISC SoCs, picorv32, osvvm and more. Read more in the online_ documentation, or get straight into business with the quick start.


7 hours

1,656 €

Bem Constructor

About

BEM Constructor

BEM Constructor is a Sass library for building immutable and namespaced BEM-style CSS objects. By enforcing a consistent and programatic way of defining objects (blocks, elements and modifiers) it ensures a more structured, robust and secure object codebase that is easy to understand and maintain. Objects defined using the constructor are impossible to modify and reassign by mistake or omission. Jump to :hamburger: The Burger Example to see the mixins in action.

Key ideas

The key ideas behind this library are well explained by Harry Roberts in his articles Immutable CSS, More Transparent UI Code with Namespaces and MindBEMding getting your head round BEM syntax,

1. Immutability

Some CSS objects in your project shouldn't be able to change (mutate). They have a very specific role and you need to make sure they're not reassigned somewhere else in your codebase. In order to ensure immutability you'll need three things: a way of defining those objects, a way of recognising them and a way to guarantee you won't be able to modify them later on. By constructing objects programatically you can be confident that they are assigned once and just once.

2. Namespacing

Objects have a clear function. Whether they are components, utilities, or dirty hacks, we need a consistent way of telling them apart. By namespacing objects, our UI code becomes more transparent and understandable. BEM Constructor supports the following object types: Read Harry's post on namespaces to get a deep look at why and how they are used.

3. BEM structure

BEM objects are composed of a block and any number of elements and/or modifiers. Using the BEM syntax for naming classes you'll produce structured code that helps you and other developers understand at a glance the relationship between those classes. The BEM constructor takes care of generating bem-compliant selectors.

4. Responsive suffixes

With responsive suffixes you are able to denote conditional states or breakpoints where permutations to an object may occur. This is specially useful when dealing with media queries that modify the base values of a given UI element.


7 hours

1,656 €

Znc Push

About

ZNC Push

Overview ZNC Push is a module for [ZNC][] that will send notifications to multiple push notification services, or SMS for any private message or channel highlight that matches a configurable set of conditions. ZNC Push current supports the following services:

  • [Boxcar][]
  • [Boxcar 2][]
  • [Pushover][]
  • [Pushsafer][]
  • [Prowl][]
  • [Supertoasty][]
  • [PushBullet][]
  • [Faast][]
  • [Nexmo][]
  • [Pushalot][]
  • [Pushjet][]
  • [Telegram][]
  • [Slack][]
  • [Discord][]
  • Custom URL GET requests This project is still a Work In Progress, but should be functional enough and stable enough for everyday usage. Users are more than welcome to submit feature requests or patches for discussion or inclusion. Bug reports and feature requests can be submitted to For full functionality, this module requires ZNC version 0.090 or newer, but should compile and run with a reduced feature set on versions as old as 0.078, the current version used by Ubuntu. However, development and testing is done exclusively against the latest source distribution, so feedback on older releases of ZNC is needed to continue supporting them. If you want to use ZNC versions before 1.0 (0.206 or older), you will need to check out the "legacy" branch in order to compile it correctly. ZNC Push was created by John Reese and designed to fill a personal need. It may not fit your use cases, but any and all feedback would be greatly appreciated. Dependencies If you have installed ZNC from a Linux distribution's repository, you will most likely need to install the development package before building this module. On Ubuntu, this can be installed with: $ sudo aptitude install znc-dev In order for this plugin to properly work, you will need to ensure you have the ca-certificates package on Ubuntu based systems. This is required for push to properly verify the certificate of the service it's sending your message to. $ sudo aptitude install ca-certificates Optionally, if you want to use libcurl for http requests, you also need to install cURL development header files. On Ubuntu, development headers can be installed by installing libcurl3-dev or libcurl4-openssl-dev package: $ sudo aptitude install libcurl4-openssl-dev Compiling If you have make installed, you can compile the module with: $ make Otherwise, run the full command: $ znc-buildmod push.cpp

    Advanced

    If you would like to compile ZNC Push using libcurl for http requests, you must use: $ make curl=yes If libcurl is not in the default system library paths, you will need to populate $CXXFLAGS with the appropriate GCC flags so that it can find and link ZNC Push with libcurl. Note: You are strongly encouraged to use libcurl transport. The reason for that is, that the default CSocket transport doesn't verify server's SSL certificate which leaves you vulnerable to MITM attacks. However, use of libcurl will block the main ZNC thread at every push notification; for installations with many users, libcurl is not yet ideal, even with the above security concerns in mind.


7 hours

1,656 €

OpenFB

About

OpenFB

OpenFB is a Micro-Library for Facebook integration in JavaScript apps running in the browser and in Cordova. OpenFB has no dependency: You don't need the Facebook plugin when running in Cordova. You also don't need the Facebook SDK. OpenFB allows you to login to Facebook and execute any Facebook Graph API request. Here are a few code examples... Login using Facebook: openFB.login(callback, {scope: 'email,read_stream,publish_actions'}); Get the user's list of friends: openFB.api({path: '/me/friends', success: successHandler, error: errorHandler}); Post on the user's feed: openFB.api( { method: 'POST', path: '/me/feed', params: { message: 'Testing the Facebook Graph API' }, success: successHandler, error: errorHandler }); The approach used in OpenFB (plain OAuth + direct requests to Graph API endpoints) is simple and lightweight, but it is definitely not perfect. Pros: Cons:

Browser and Cordova Apps

The library works for both browser-based apps and Cordova/PhoneGap apps. When running in a browser, the OAuth URL redirection workflow happens in a popup window. When running in Cordova, it happens inside an "In-App Browser".


7 hours

1,656 €

CORScanner

About

About CORScanner

CORScanner is a python tool designed to discover CORS misconfigurations vulnerabilities of websites. It helps website administrators and penetration testers to check whether the domains/urls they are targeting have insecure CORS policies.

Features

  • Fast. It uses gevent instead of Python threads for concurrency, which is much faster for network scanning.
  • Comprehensive. It covers all the common types of CORS misconfigurations we know.
  • Flexible. It supports various self-define features (e.g. file output), which is helpful for large-scale scanning. Two useful references for understanding CORS systematically:
  • USENIX security 18 paper: We Still Dont Have Secure Cross-Domain Requests: an Empirical Study of CORS
  • SOPCORS

    Screenshots


7 hours

1,656 €

Nproxy

About

NProxy

A cli proxy tool specialized in file replacing

Why NProxy

Maybe you have such question as why NProxy when we have Fiddler, Charles, Rythem and Tinyproxy. Yes, there is no doubt that they are all great tools, however they don't meet my requirements:

  • Support Mac, Linux and Windows(especially Mac and Linux)
  • Support replacing combo files with separated source files
  • Support directory mapping This is the main reason why NProxy is here. Besides, NProxy can improve the efficiency of my daily development for enterprise-level product with a bunch of complex building processes, which cost me lots of time. I've written a post named NProxy: The Mjolnir for UI Developers and a keynote NProxy: A Sharp Weapon for UI Developers to explain my reason for developing NProxy in detail.

    Features

  • Support Mac, Linux and Windows
  • Support both single file and combo file replacing
  • Support directory mapping with any files
  • Support both HTTP and HTTPS

7 hours

1,656 €

SmileTouchID

About

SmileTouchID

A library for integrate Touch ID & Passcode to iOS App conveniently.

What can it do for you?

1. Handle all complicated things about Touch ID & Passcode. You just need to write a few simple code to integrate Touch ID & Passcode to your app.

For example, handle the device that not support Touch ID, instead of Touch ID, use Passcode for authentication. handle the whole process about securing the app (the user change passcode or turn passcode off), if ([SmileAuthenticator hasPassword]) { }

2. Get elegant animation and adaptive UI automatically.

3. Can customize the colorTouch ID icon and background image to fit your app style. For example, you can customize like the below image.

You can use the property nightMode to change all the UI element to black style, like the below image.

4. Can customize the passcode digit to 6 or 10, or any number, automatically handle other things for you.

If you want to try this feature in the demo app, before you try to change passcodeDigit to new number, make sure turn off the passcode switch, because the keychain will save your old passcode even you delete the app, so you have to clear the old passcode in keychain, and then change new digit for test.

5. Support iOS7 and later.

In iOS7, because Apple had not given the TouchID API to developers, only use Passcode for authentication.

Theoretical Introduction

The main class is the SmileAuthenticator. It has a property SecurityType that has four types INPUT_ONCE, INPUT_TWICE, INPUT_THREE, INPUT_TOUCHID. The reason for this name is that show the user input times. INPUT_ONCE: For the user turn the passcode switch off, user need input their passcode only one time for turn the password off. INPUT_TWICE: For the user turn the password switch on, user need input their password once and re-enter their password one more time for confirm it to match each other. INPUT_THREE: For the user change the password, user need input their old passcode one time, then input their new passcode one time and re-enter one time for confirm, a total of three times. INPUT_TOUCHID: For the user open the app, user can use touch ID or input passcode to unlock.


7 hours

1,656 €

Knapsack

About

Knapsack

Collection pipeline library for PHP Knapsack is a collection library for PHP >= 5.6 that implements most of the sequence operations proposed by Clojures sequences plus some additional ones. All its features are available as functions (for functional programming) and as a collection pipeline object methods. The heart of Knapsack is its Collection class. However its every method calls a simple function with the same name that does the actual heavy lifting. These are located in DusanKasan\Knapsack namespace and you can find them here. Collection is a Traversable implementor (via IteratorAggregate) that accepts Traversable object, array or even a callable that produces a Traversable object or array as constructor argument. It provides most of Clojures sequence functionality plus some extra features. It is also immutable - operations preformed on the collection will return new collection (or value) instead of modifying the original collection.

Most of the methods of Collection return lazy collections (such as filter/map/etc.). However, some return non-lazy collections (reverse) or simple values (count). For these operations all of the items in the collection must be iterated over (and realized). There are also operations (drop) that iterate over some items of the collection but do not affect/return them in the result. This behaviour as well as laziness is noted for each of the operations.
If you want more example usage beyond what is provided here, check the specs and/or scenarios. There are also performance tests you can run on your machine and see the computation time impact of this library (the output of these is included below). Feel free to report any issues you find. I will do my best to fix them as soon as possible, but community pull requests to fix them are more than welcome.


7 hours

1,656 €

SysAdminBoard

About

SysAdminBoard

SysAdminBoard is a simple dashboard system written in Python, HTML and Javascript and served on a simple CherryPy Webserver (included). It was originally written to reformat snmp data for the Panic Statusboard iPad App, but has since become a fully stand-alone project that can grab data from a variety of sources and render charts and graphs in a web browser. Here is an older photo our installation. We use some small ASUS chromeboxes along with the Chrome Kiosk extension to display our dashboards.

Features

VMware vSphere ESX Host Monitoring

This module will talk to a VMware vSphere vCenter server using VMware APIs to get data about ESX hosts. Items are sorted based on top CPU usage over a 30 minute period.

VMware vSphere VM Monitoring

This module will talk to a VMware vSphere vCenter server using VMware APIs to get data about the top ESX VMs. Items are sorted based on top CPU usage over a 30 minute period.

Network Bandwidth Monitoring

This module demonstrates how to grab network bandwidth data. In the first image, it is pulling in snmp data from a Palo Alto Firewall. In the second image, it is pulling snmp data some VLANs on a Cisco Catalyst 6880 switch.

SNMP Network Monitoring

This module demonstrates how to grab SNMP table data. In this case, it is pulling in ISDN values from a Cisco Voice Gateway to show the number of active phone calls.

SNMP Temperature Gadget

This module talks to a couple different APC devices to pull in temperature, humidity, voltage and runtime data.

Exchange Monitoring

This module monitors a Microsoft Exchange server to display SMTP message totals for the day along with RPC and latency information (per CAS server). Note that this code requires my pyPerfmon app running on each Exchange server to be monitored.

Tintri Monitoring

This module monitors a Tintri hybrid storage device using REST API calls.

Rubrik Monitoring

This module monitors a Rubrik backup system using REST API calls.

Nutanix Monitoring

This module monitors a Nutanix hyperconverged system using REST API calls. The first image shows cluster monitoring. The second Nutanix gadget shows per-VM storage monitoring. It shows the top X VMs in the cluster sorted by IOPS based over a 30 minute window.

Weather

This is a simple javascript-only weather gadget that pulls data from OpenWeatherMap.org. If you use this gadget, please sign up for a free APPID on that site and edit the source file to include your code.

Clock

This is a great javascript-only clock from YXKFW.

 


7 hours

1,656 €

MariOCaml

About

MariOCaml is an HTML 5 canvas web-browser implementation of the Super Mario Bros platformer written exclusively in Ocaml.

Key Features

  • 2D Mario platformer that emulates the platformer mechanics of Super Mario Bros.
  • Web-based playable implementation with graphics (Ocaml transpiled to javascript).
  • Procedural level generator that randomly generates levels.

    Description

    MariOcaml is an OCaml implementation of Super Mario Bros. The game includes several basic enemies, blocks, and items, with particle support. The underlying system follows a director model, with the director maintaining state based on game objects and tiles, including Mario, items, and obstacles. The implementation of enemies and items is designed to be easily extensible. Furthermore, MariOcaml supports a game-over and game-win states, as well as score and coin counts, emulating several of the core mechanics of Mario. The design follows a clean, modular, and extensible system to ensure that more features can easily be added. Levels are procedurally generated (pseudo-randomly), algorithmically creating an environment of textures and objects that are interactable. The procedural generation generally generates a playable map, but due to the nature of random generation, maps may not be the most aesthetically appealing. Additionally, the game is interactive and graphical using js_of_ocaml, which enables cross-compiliation of Ocaml to javascript, allowing MariOcaml to be run in any modern web browser. The underlying procedural generation utilizes a grid system to generate objects, taking account parameters such as proximity and location. During game-play, the director maintains the game state, including the location and status of both items, enemies, and the character.

Content

  • Modules
  • Building the Project

 


7 hours

1,656 €

Bashible

About

BASHIBLE

Bashible is a deployment/automation tool written in Bash (DSL). Inspired by Ansible. Simplifies things and prevents usual mistakes. Features: At the moment, bashible has been used on Arch linux. It may not be compatible with other platforms, because it internally uses GNU/sed, grep, etc. Suggestions and bugfixes are welcome!

Example output

Example script.bash

@ represents a block of tasks, - represents a task. Both @ and - are just bash functions with arguments.

!/usr/local/bin/bashible

the working directory is automatically set to the script's

all tasks will stop execution immediately on failure, unless prefixed by "may_fail"

@ Synchronizing files @ Shutting down the machine @ Sending an e-mail unless synchronization succeeded Rewritten into pure Bash, the example above could look like this,

!/bin/bash

cd dirname $0 set -eux -o pipefail echo Synchronizing files if rsync -av /foo /bar; then echo Shutting down the machine if test -f /etc/do-shutdown; then shutdown -h now fi else echo 


7 hours

1,656 €

Mintotp

About

MinTOTP

MinTOTP is a minimal TOTP generator written in Python. Contents

  • Introduction
  • Source Code
  • Install
    • From PyPI
    • From GitHub
  • Get Started
    • With Base32 Key
    • With QR Code
  • Protect Key with GPG
    • Install GPG
    • Encrypt Base32 Key with GPG
    • Encrypt QR Code with GPG
  • Usage
    • Multiple Keys
    • Command Line Arguments
  • Tradeoff
  • Alternative: OATH Toolkit
  • Resources
  • License
  • Thanks Introduction TOTP stands for Time-Based One-Time Password. Many websites and services require two-factor authentication (2FA) or multi-factor authentication (MFA) where the user is required to present two or more pieces of evidence: A TOTP value serves as the second factor, i.e., it proves that the user is in possession of a device (e.g., mobile phone) that contains a TOTP secret key from which the TOTP value is generated. Usually the service provider that provides a user's account also issues a secret key encoded either as a Base32 string or as a QR code. This secret key is added to an authenticator app (e.g., Google Authenticator) on a mobile device. The app can then generate TOTP values based on the current time. By default, it generates a new TOTP value every 30 seconds. MinTOTP is a Python tool that can be used to generate TOTP values from a secret key. Additionally, it exposes its functionality as module-level functions for Python developers. It can be used on any system with Python 3.4 or later installed on it. Source Code At the heart of the TOTP algorithm lies the HOTP algorithm. HOTP stands for HMAC-based One-Time Password. HMAC stands for Hash-based Message Authentication Code. Here are the relevant RFCs to learn more about these algorithms: The source code in [mintotp.py][src] generates TOTP values from a secret key and current time. It's just 30 lines of code (actually 20 lines if we ignore the shebang and blank lines). There are no comments in the code, so a brief description of the code is presented in this section. Here is the entire code presented once again for convenience:

    !/usr/bin/python3

    import base64 import hmac import struct import sys import time def hotp(key, counter, digits=6, digest='sha1'): key = base64.b32decode(key.upper() + '=' ((8 - len(key)) % 8)) counter = struct.pack('>Q', counter) mac = hmac.new(key, counter, digest).digest() offset = mac[-1] & 0x0f binary = struct.unpack('>L', mac[offset:offset+4])[0] & 0x7fffffff return str(binary)[-digits:].rjust(digits, '0') def totp(key, time_step=30, digits=6, digest='sha1'): return hotp(key, int(time.time() / time_step), digits, digest) def main(): args = [int(x) if x.isdigit() else x for x in sys.argv[1:]] for key in sys.stdin: print(totp(key.strip(), args)) if name == 'main': main() In the code above, we use the hmac module available in the Python standard library to implement HOTP. The implementation can be found in the hotp() function. It is a pretty straightforward implementation of Base32-encoded secret key and a counter as input. It returns a 6-digit HOTP value as output. The totp() function implements the TOTP algorithm. It is a thin wrapper around the HOTP algorithm. The TOTP value is obtained by invoking the HOTP function with the secret key and the number of time intervals (30 second intervals by default) that have elapsed since Unix epoch (1970-01-01 00:00:00 UTC).


7 hours

1,656 €

Minos

About

What is Minos

Minos is a distributed deployment and monitoring system. It was initially developed and used at Xiaomi to deploy and manage the Hadoop, HBase and ZooKeeper clusters used in the company. Minos can be easily extended to support other systems, among which HDFS, YARN and Impala have been supported in the current release.

Components

The Minos system contains the following four components:

  • Client
  • Owl
  • Supervisor
  • Tank

    Client

    This is the command line client tool used to deploy and manage processes of various systems. You can use this client to perform various deployment tasks, e.g. installing, (re)starting, stopping a service. Currently, this client supports ZooKeeper, HDFS, HBase, YARN and Impala. It can be extended to support other systems. You can refer to the following Using Client to learn how to use it.

    Owl

    This is the dashboard system to display the status of all processes, where users can take a overview of the whole clusters managed by Minos. It collects data from servers through JMX interface. And it organizes pages in cluster, job and task corresponding to the definition in cluster configuration. It also provides some utils like health alerter, HDFS quota updater and quota reportor. You can refer to Installing Owl to learn how to install and use it.

    Supervisor

    This is the process management and monitoring system. Supervisor is an open source project, a client/server system that allows its users to monitor and control a number of processes on a UNIX-like operating system. Based on the version of supervisor-3.0b1, we extended Supervisor to support Minos. We implemented an RPC interface under the deployment directory, so that our deploy client can invoke the services supplied by supervisord. When deploying a Hadoop cluster for the first time, you need to set up supervisord on every production machine. This only needs to be done once. You can refer to Installing Supervisor to learn how to install and use it.

    Tank

    This is a simple package management Django app server for our deployment tool. When setting up a cluster for the first time, you should set up a tank server first. This also needs to be done only once. You can refer to Installing Tank to learn how to install and use it.

    Setting Up Minos on Centos/Ubuntu

    Prerequisites


7 hours

1,656 €

Webcodesk Srv

About

Webcodesk is an application that installed as an npm module. It consists of two parts: a server part and a client part. The server part is a NodeJS application that should be started in the command line on the local computer. The client part runs in the web browser. Webcodesk helps the developer in creating Web applications with React UI components. It has a bunch of visual editors where the user can compose UI components on the pages, create data flow logic between UI components, and debug data flow visually.

Introduction

Read the article on Hackernoon about why Webcodesk was created:

  • I Developed A Visual Development Tool For Web Applications with React The best way to tell about Webcodesk is to let you try it in action. So I would recommend you to complete the tutorial in the online version of Webcodesk. Click on the link below.
  • Start Online Demo Here you can see the first part of creating a ToDo application in Webcodesk.
  • Timelapse Video

    To React developers

    Your experience will tell you that you do not need any visual builders because they are limited in functionality, unreliable, and they all suck. Give Webcodesk a chance and try to create your own small single-page application, I assure you, you won't ever want to write a ton of extra code.

  • You don't have to learn anything new. Rather, you will not write any unnecessary code for Redux.
  • Webcodesk does not generate code. It uses a small framework that is reliable. The proof of reliability is the fact that the framework is used inside Webcodesk itself.

7 hours

1,656 €

HapticButton

About

HapticButton

Description

HapticButton replicates the behavior of the buttons in the iOS 10 and 11 Control Center as well as in the Home app. A device with 3D Touch is required to fully experience the haptic feedback on supported devices. It is implemented as a subclass of UIControl, so feel free to further customize it to your needs. The user is required to press the button and activate 3D Touch with a minimum pressure threshold (you can specify the minimum value to trigger the button via the feedbackThreshold property). This allows for a cool interaction that gives a haptic feedback to the user when the button is triggered. For the best experience, install the example on a device. The example project shows how to set up HapticButton in a few different ways. @IBOutlet weak var button: HapticButton! button.mode = .label(text: "Hello! ") // Use the delegate method to be notified when the button is pressed. button.delegate = self let blurButton = HapticButton(mode: .image(image: #imageLiteral(resourceName: "swift"))) blurButton.addBlurView(style: .light) // Add custom target selector to the touch up inside event. blurButton.addTarget(self, action: #selector(blurButtonPressed(_:)), for: .touchUpInside) let blurButton = HapticButton(mode: .label(text: "Hello Blur!")) darkBlurButton.textLabel.textColor = .white darkBlurButton.addBlurView(style: .dark) // Pass closure to be invoked when the button is pressed. darkBlurButton.onPressed = { print("Dark blur button pressed.") }

Customizations

These are the public properties that allow you to customize the control. In case you are thinking to modify HapticButton even further, consider creating a Pull Request! public weak var delegate: HapticButtonDelegate? /// The closure invoked when the button is pressed. public var onPressed: Callback? /// The minimum pressure that the button press has to receive in order to trigger the related haptic feedback. The value has to be between 0 and 1 and the default is 0.25. public var feedbackThreshold = 0.25 /// If the button is in mode label, this UILabel is part of the button hierarchy. Modify this object directly for more customizations on the displayed text. public lazy var textLabel: UILabel /// If the button is in mode image, this UIImageView is part of the button hierarchy. Modify this object directly for more customizations on the displayed image. public lazy var imageView: UIImageView /// The current mode of the button. public var mode = HapticButtonMode.label(text: "Title")

Requirements

iOS 10.0 and Swift 3.2 are required. If you are using Swift 4, please use the swift4 branch.

Installation

HapticButton is available through CocoaPods. To install it, simply add the following line to your Podfile: pod "HapticButton" You can also use Carthage if you prefer. Add this line to your Cartfile. github "BalestraPatrick/HapticButton"

Author

I'm Patrick Balestra.


7 hours

1,656 €

NFHTTP

About

A cross platform C++ HTTP framework.

Raison D'être :thought_balloon:

At Spotify we have performed studies that show the efficacy of using native backed solutions for interfacing to backends, especially when it came to the battery life of certain devices. In order to carry this forward in the cross-platform C++ world, we created this library that provides a common interface to many of the system level HTTP interfaces, and predictable caching and request hooking. We found that many of the current solutions that claimed to do this lacked key supports for many kinds of platforms, and ended up being libraries that heavily favoured 1 platform and gave the other platforms a generic implementation. We also wanted to provide a caching layer that was consistent across all platforms in our layered architecture.

Architecture :triangular_ruler:

NFHTTP is designed as a common C++ interface to communicate with different systems over HTTP! The API allows you to create objects to make Requests and read Responses. To initiate, send and receive messages you create and use a Client object. This is a layered architecture where requests and responses can pass through multiple places in the stack and get decorated or have actions taken upon them. The layer design is as follows: Our support table looks like so: In addition to this, it is also possible to use curl on any of the above platforms or boost ASIO (provided by CPP REST SDK).

Dependencies :globe_with_meridians:

  • C++ REST SDK
  • curl
  • JSON for Modern C++
  • OpenSSL
  • SQLite
  • boost

7 hours

1,656 €

Simplehttp

About

simplehttp

simplehttp is a family of libraries and daemons built upon libevent that make high performance HTTP servers simple and straightforward to write. The following libraries and daemons are included:

  • buffered_socket - a simple abstraction on bufferevent for arbitrary TCP sockets
  • domain_socket - an async C library for creating, listening, and communicating over unix domain sockets
  • host_pool - a library for dealing with endpoint selection, pooling, failure, recovery, and backoff
  • profiler_stats - a library to track arbitrary profiler timings for average, 95%, 99%, 100% time
  • ps_to_http - a daemon built on top of pubsubclient to write messages from a source pubsub to destination simplequeue or pubsub server
  • ps_to_file - a daemon built on top of pubsubclient to write messages from a source pubsub to time rolled output files
  • pubsub - a daemon that receives data via HTTP POST events and writes to all subscribed long-lived HTTP connections
  • pubsub_filtered - a pubsub daemon with the ability to filter/obfuscate fields of a JSON message
  • pubsubclient - a library for writing clients that read from a pubsub
  • pysimplehttp - a python library for working with pubsub and simplequeue
  • qrencode
  • queuereader - a library for writing clients that read from a simplequeue and do work
  • simpleattributes
  • simplegeo
  • simplehttp
  • simpleleveldb - a HTTP CRUD interface to leveldb
  • simplememdb - an in-memory version of simpletokyo
  • simplequeue - an in memory queue with HTTP /put and /get endpoints to push and pop data
  • simpletokyo - a HTTP CRUD interface to front tokyo cabinet's ttserver
  • sortdb - sorted database server simplehttp Install Instructions


7 hours

1,656 €

Battery Metrics

About

Battery Metrics

Battery Metrics is a lightweight android library to quickly instrument several metrics for understanding battery consumption. As a developer, it's surprisingly hard to understand how your application affects battery life on Android — relying on the operating system level reported battery level tends to be inaccurate (because the reported levels are fairly coarse, affected by every app running on the device and smoothed out) and while it's possible to get really good measurements locally you don't really know what sort of experience users are having in the wild. The library helps instrument hardware utilization to be able to understand how the application is behaving -- most of the underlying hardware metrics are either exposed by the OS, or not directly accessible -- which is where this library comes into play. We've written several metrics collectors that read from procfiles, or provide a consistent way to call into to instrument your application.

Adding BatteryMetrics

Add jcenter to your repositories repositories { jcenter() } And add dependencies on the projects you'd like to use in build.gradle dependencies { implementation 'com.facebook.battery:metrics:1.0.0' implementation 'com.facebook.battery:reporters:1.0.0' // optional implementation 'com.facebook.battery:serializers:1.0.0' // optional }

Quick Start

As a simple quickstart, let's instrument sample activity to check CPU time while the activity is being used in the foreground -- class SampleActivity extends Activity { private static final CpuMetricsCollector sCollector = new CpuMetricsCollector(); private final CpuMetrics mInitialMetrics = sCollector.createMetrics(); private final CpuMetrics mFinalMetrics = sCollector.createMetrics(); @Override protected void onResume() { super.onResume(); sCollector.getSnapshot(mInitialMetrics); } @Override protected void onPause() { super.onPause(); sCollector.getSnapshot(mFinalMetrics); Log.d("BatteryMetrics", mFinalMetrics.diff(mInitialMetrics).toString()); } } And foregrounding and background the application prints the metrics to logcat -- CpuMetrics{userTimeS=0.06, systemTimeS=0.04, childUserTimeS=0.0, childSystemTimeS=0.0}

Sample App


7 hours

1,656 €

Sp Starter Kit

About

SharePoint Starter Kit v2

The SharePoint Starter Kit (starter kit) is a comprehensive solution designed for SharePoint Online and SharePoint 2019 which provides numerous SharePoint Framework (SPFx) web parts, extensions, and other components, as well as PnP PowerShell driven provisioning which you can use as an example and inspiration for your own customizations.

Starter Kit Version 1 includes a comprenshive strategy for only SharePoint Online, as well as a single SPFx solution that encapsulates all webparts and extensions into a single package. Version 1 may be accessed via the v1 branch for legacy purposes and will not be maintained beyond April 2020. Notice: There currently is not a direct path for upgrading an existing SharePoint Online tenant with the starter kit v1 to v2. V2 may be installed into a tenant with v1 already installed, by default, this will add a tenant wide duplicate all of webparts and extensions. It is recommended that the starter kit v1 be removed from a tenant before adding v2, or creating a custom installation of v2. Notice: the starter kit adds tenant level settings including themes, site designs, taxonomy term sets, and other adjustments. Therefore, it is recommended to test the starter kit in an isolated test tenant and not immediately execute it within your production environment.

Table of contents

Objectives of this solution

SharePoint Communication Sites and Team Sites have great out-of-the-box capabilities, although the out-of-the-box capabilities may not always be sufficient for your scenarios. This is exactly why SharePoint may be extended and you are able to include your own customizations. This solution addresses common scenarios and tasks you may encounter when introducing those customizations, and provides examples and guidance on how you might address and provision them including: Additional high resolution screenshots are also available: front page.

SharePoint Starter Kit v2 has following objectives

  • Extend the success of v1 by providing developers a customization and provisioning strategy for SharePoint
  • Demonstrate new SharePoint Online UX design and layout capabilities including:
  • Full height vertical columns
  • Compact headers
  • Mega menus
  • Background theming
  • SharePoint 2019 compatible starter kit with web parts and components supported by SharePoint 2019 - (provisioning template coming soon)
  • Support web parts, extensions, and libraries (SPO only) to be deployed one-by-one to tenants or farms
  • Demonstrate teams tab development with SharePoint Framework for suitable web parts in SharePoint Online
  • Demonstrate Microsoft Graph API and Graph Toolkit usage in SharePoint Online

    Pre-requirements

    Here are current pre-requirements for making this solution work in your tenant.

    1. You will need to be a tenant administrator to be able to deploy this solution
    2. Automatic end-to-end provisioning only works with English tenants
    3. Release preferences for your SharePoint Online tenant will need to be set as "Targeted release for everyone" option (also known as First Release)
    4. Add the tenant administrator account used during provisioning as Term Store Administrator in the Taxonomy Term Store through the SharePoint Admin Center (SPO) or Central Admin (SP2019)
    5. A tenant 'App Catalog' must have been created within the 'Apps' option of the SharePoint Admin Center (SPO) or Central Admin (SP2019) It is recommended that you wait up to 24 hours before attempting to provision this solution if any of the following are true
  • Your SharePoint tenant was just created
  • You just created your SharePoint tenant app catalog
  • You just set your tenant as "Targeted release for everyone" (SPO)

7 hours

1,656 €

MDK SE

About

MDK-SE

(Malware's Development Kit for SE) A toolkit to help with ingame script (programmable block) development for Keen Software House's space sandbox Space Engineers. It helps you create a ready-to-code project for writing ingame scripts, and provides an analyzer which warns you if you're trying to use something that is not allowed in Space Engineers. Because there hasn't been any need to. It's for all intents and purposes "done". If and when something breaks it, either a Visual Studio update or an SE update, I will do my best to fix it. Or, obviously, if I come up with a feature I want... but for now, there's nothing to do. "But there's bugs", I hear you say. Yeah, there's some minor issues. But they're small enough that I can't manage to find the time to fix them. I have limited time for this and not much help...

Can I use this in VSCode?

No. Visual Studio Code and Visual Studio has nothing in common outside of the name.

General features

  • Helps you create a fully connected script project in Visual Studio, with all references in place
  • Requires that you have the game installed, but does not require you to have it running
  • Class templates for normal utility classes and extension classes
  • Tells you if you're using code that's not allowed in Space Engineers (whitelist checker)
  • Deploys multiple classes into a single PB script, which then is placed in the local Workshop space for easy access in-game - no copy/paste needed
  • Supports optional code minifying: Fit more code within the limits of the programmable block
  • Allows real reusable code libraries through the use of Visual Studio's Shared Project
  • Out-of-game script blueprint manager allows you to rename and delete script blueprints without starting the game

    Quick links

  • MDK/SE Wiki page
  • Getting Started
  • Quick Introduction to Space Engineers Ingame Scripts
    (You don't have to use the extension to get something out of this guide)
  • Contributing to MDK Space Engineers is trademarked to Keen Software House. This toolkit is fan-made, and its developer has no relation to Keen Software House.

7 hours

1,656 €

Rumale

About

Rumale

Rumale (Ruby machine learning) is a machine learning library in Ruby. Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python. Rumale supports Support Vector Machine, Logistic Regression, Ridge, Lasso, Multi-layer Perceptron, Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest, K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering, Mutidimensional Scaling, t-SNE, Fisher Discriminant Analysis, Neighbourhood Component Analysis, Principal Component Analysis, Non-negative Matrix Factorization, and many other algorithms.


7 hours

1,656 €

Gramm

About

Gramm is a data visualization toolbox for Matlab that allows to produce publication-quality plots from grouped data easily and flexibly. Matlab can be used for complex data analysis using a high-level interface: it supports mixed-type tabular data via tables, provides statistical functions that accept these tables as arguments, and allows users to adopt a split-apply-combine approach (Wickham 2011) with rowfun(). However, the standard plotting functionality in Matlab is mostly low-level, allowing to create axes in figure windows and draw geometric primitives (lines, points, patches) or simple statistical visualizations (histograms, boxplots) from numerical array data. Producing complex plots from grouped data thus requires iterating over the various groups in order to make successive statistical computations and low-level draw calls, all the while handling axis and color generation in order to visually separate data by groups. The corresponding code is often long, not easily reusable, and makes exploring alternative plot designs tedious. Inspired by ggplot2 (Wickham 2009), the R implementation of "grammar of graphics" principles (Wilkinson 1999), gramm improves Matlab's plotting functionality, allowing to generate complex figures using high-level object-oriented code. Gramm has been used in several publications in the field of neuroscience, from human psychophysics (Morel et al. 2017), to electrophysiology (Morel et al. 2016; Ferrea et al. 2017), human functional imaging (Wan et al. 2017) and animal training (Berger et al. 2017).

Compatibility

Tested under Matlab 2014b+ versions. With pre-2014b versions, gramm forces 'painters', renderer to avoid some graphic bugs, which deactivates transparencies (use non-transparent geoms, for example stat_summary('geom','lines')). The statistics toolbox is required for some methods: stat_glm(), some stat_summary() methods, stat_density(). The curve fitting toolbox is required for stat_fit().


7 hours

1,656 €

Braintree Php

About

Braintree PHP library

The Braintree PHP library provides integration access to the Braintree Gateway.

TLS 1.2 required

The Payment Card Industry (PCI) Council has mandated that early versions of TLS be retired from service. All organizations that handle credit card information are required to comply with this standard. As part of this obligation, Braintree has updated its services to require TLS 1.2 for all HTTPS connections. Braintrees require HTTP/1.1 for all connections.

Dependencies

The following PHP extensions are required:

  • curl
  • dom
  • hash
  • openssl
  • xmlwriter PHP version >= 7.2 is required. The Braintree PHP SDK is tested against PHP versions 7.3 and 7.4. The PHP core development community has released End-of-Life branches for PHP versions 5.4 - 7.1. As a result, Braintree does not support these versions of PHP.

    Versions

    Braintree employs a deprecation policy for our SDKs. For more information on the statuses of an SDK check our developer docs.


7 hours

1,656 €

Habitat Lab

About

Habitat Lab

Habitat Lab is a modular high-level library for end-to-end development in embodied AI -- defining embodied AI tasks (e.g. navigation, instruction following, question answering), configuring embodied agents (physical form, sensors, capabilities), training these agents (via imitation or reinforcement learning, or no learning at all as in classical SLAM), and benchmarking their performance on the defined tasks using standard metrics. Habitat Lab currently uses Habitat-Sim as the core simulator, but is designed with a modular abstraction for the simulator backend to maintain compatibility over multiple simulators. For documentation refer here. We also have a dev slack channel, please follow this link to get added to the channel.

Table of contents

  1. Motivation
  2. Citing Habitat
  3. Installation
  4. Example
  5. Documentation
  6. Docker Setup
  7. Details
  8. Data
  9. Baselines
  10. License
  11. Acknowledgments
  12. References

    Motivation

    While there has been significant progress in the vision and language communities thanks to recent advances in deep representations, we believe there is a growing disconnect between internet AI and embodied AI. The focus of the former is pattern recognition in images, videos, and text on datasets typically curated from the internet. The focus of the latter is to enable action by an embodied agent in an environment (e.g. a robot). This brings to the forefront issues of active perception, long-term planning, learning from interaction, and holding a dialog grounded in an environment. To this end, we aim to standardize the entire software stack for training embodied agents scanning the world and creating highly photorealistic 3D assets, developing the next generation of highly efficient and parallelizable simulators, specifying embodied AI tasks that enable us to benchmark scientific progress, and releasing modular high-level libraries to train and deploy embodied agents.

    Citing Habitat

    If you use the Habitat platform in your research, please cite the following paper: @inproceedings{habitat19iccv, title = {Habitat: {A} {P}latform for {E}mbodied {AI} {R}esearch}, author = {Manolis Savva and Abhishek Kadian and Oleksandr Maksymets and Yili Zhao and Erik Wijmans and Bhavana Jain and Julian Straub and Jia Liu and Vladlen Koltun and Jitendra Malik and Devi Parikh and Dhruv Batra}, booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)}, year = {2019} }


7 hours

1,656 €

Diffplex

About

DiffPlex

DiffPlex is C# library to generate textual diffs. It targets netstandard1.0.

About the API

The DiffPlex library currently exposes two interfaces for generating diffs:

  • IDiffer (implemented by the Differ class) - This is the core diffing class. It exposes the low level functions to generate differences between texts.
  • ISidebySideDiffer (implemented by the SideBySideDiffer class) - This is a higher level interface. It consumes the IDiffer interface and generates a SideBySideDiffModel. This is a model which is suited for displaying the differences of two pieces of text in a side by side view.

    Examples

    For examples of how to use the API please see the the following projects contained in the DiffPlex solution. For use of the IDiffer interface see:

  • SidebySideDiffer.cs contained in the DiffPlex Project.
  • UnidiffFormater.cs contained in the DiffPlex.ConsoleRunner project. For use of the ISidebySideDiffer interface see:
  • DiffController.cs and associated MVC views in the WebDiffer project
  • TextBoxDiffRenderer.cs in the SilverlightDiffer project

    Sample code

    var diff = InlineDiffBuilder.Diff(before, after); var savedColor = Console.ForegroundColor; foreach (var line in diff.Lines) { switch (line.Type) { case ChangeType.Inserted: Console.ForegroundColor = ConsoleColor.Green; Console.Write("+ "); break; case ChangeType.Deleted: Console.ForegroundColor = ConsoleColor.Red; Console.Write("- "); break; default: Console.ForegroundColor = ConsoleColor.Gray; // compromise for dark or light background Console.Write(" "); break; } Console.WriteLine(line.Text); } Console.ForegroundColor = savedColor;

    IDiffer Interface

    /// /// Provides methods for generate differences between texts /// public interface IDiffer { /// /// Create a diff by comparing text line by line /// /// The old text. /// The new text. /// if set to true will ignore white space when determining if lines are the same. /// A DiffResult object which details the differences DiffResult CreateLineDiffs(string oldText, string newText, bool ignoreWhiteSpace); /// /// Create a diff by comparing text character by character /// /// The old text. /// The new text. /// if set to true will treat all whitespace characters are empty strings. /// A DiffResult object which details the differences DiffResult CreateCharacterDiffs(string oldText, string newText, bool ignoreWhitespace); /// /// Create a diff by comparing text word by word /// /// The old text. /// The new text. /// if set to true will ignore white space when determining if words are the same. /// The list of characters which define word separators. /// A DiffResult object which details the differences DiffResult CreateWordDiffs(string oldText, string newText, bool ignoreWhitespace, char[] separators); /// /// Create a diff by comparing text in chunks determined by the supplied chunker function. /// /// The old text. /// The new text. /// if set to true will ignore white space when determining if chunks are the same. /// A function that will break the text into chunks. /// A DiffResult object which details the differences DiffResult CreateCustomDiffs(string oldText, string newText, bool ignoreWhiteSpace, Func chunker); /// /// Create a diff by comparing text line by line /// /// The old text. /// The new text. /// if set to true will ignore white space when determining if lines are the same. /// Determine if the text comparision is case sensitive or not /// Component responsible for tokenizing the compared texts /// A DiffResult object which details the differences DiffResult CreateDiffs(string oldText, string newText, bool ignoreWhiteSpace, bool ignoreCase, IChunker chunker); }

    IChunker Interface

    public interface IChunker { /// /// Dive text into sub-parts /// string[] Chunk(string text); } Currently provided implementations:

    ISideBySideDifferBuilder Interface

    /// /// Provides methods that generate differences between texts for displaying in a side by side view. /// public interface ISideBySideDiffBuilder { /// /// Builds a diff model for displaying diffs in a side by side view /// /// The old text. /// The new text. /// The side by side diff model SideBySideDiffModel BuildDiffModel(string oldText, string newText); }

    Sample Website

    DiffPlex also contains a sample website that shows how to create a basic side by side diff in an ASP MVC website.

    WPF Controls

    DiffPlex WPF control library DiffPlex.Wpf is used to render textual diffs in your WPF application. It targets .NET Core 3.1.


7 hours

1,656 €

Pyrdp

About

PyRDP

PyRDP is a Python 3 Remote Desktop Protocol (RDP) Man-in-the-Middle (MITM) and library. It features a few tools: PyRDP was introduced in 2018 in which we demonstrated that we can catch a real threat actor in action. This tool is being developed with both pentest and malware research use cases in mind.

Table of Contents

  • Using the Docker Image
  • From Git Source
  • Installing on Windows
  • Building the Docker Image
  • Migrating away from pycrypto
  • Using the PyRDP Man-in-the-Middle
    • Specifying the private key and certificate
    • Connecting to the PyRDP player
    • Running payloads on new connections
    • Other MITM arguments
  • Using the PyRDP Player
    • Playing a replay file
    • Listening for live connections
    • Changing the listening address
    • Other player arguments
  • Using the PyRDP Certificate Cloner
    • Cloning a certificate
    • Using a custom private key
    • Other cloner arguments
  • Using PyRDP Convert
  • Configuring PyRDP
  • Using PyRDP as a Library
  • Using PyRDP with twistd
  • Using PyRDP with Bettercap
  • Docker Specific Usage Instructions
    • Mapping a Listening Port
    • Logs and Artifacts Storage
    • Using the GUI Player in Docker

      Supported Systems

      PyRDP should work on Python 3.6 and up. This tool has been tested to work on Python 3.6 on Linux (Ubuntu 18.04) and Windows (See section Installing on Windows). It has not been tested on OSX.


7 hours

1,656 €

PhpMyFAQ

About

phpMyFAQ 3.1

What is phpMyFAQ?

phpMyFAQ is a multilingual, completely database-driven FAQ-system. It supports various databases to store all data, PHP 7.3+ is needed in order to access this data. phpMyFAQ also offers a multi-language Content Management System with a WYSIWYG editor and an Image Manager, real time search support with Elasticsearch, flexible multi-user support with user and group based permissions on categories and records, a wiki-like revision feature, a news system, user-tracking, 40+ supported languages, enhanced automatic content negotiation, HTML5/CSS3 based responsive templates, PDF-support, a backup and restore system, a dynamic sitemap, related FAQs, tagging, enhanced SEO features, built-in spam protection systems, OpenLDAP and Microsoft Active Directory support, and an easy to use installation and update script.

Requirements

phpMyFAQ is only supported on PHP 7.3 and up, you need a database as well. Supported databases are MySQL, MariaDB, Percona Server, PostgreSQL, Microsoft SQL Server and SQLite3. If you want to use Elasticsearch as main search engine, you need Elasticsearch 5.x or later as well.


7 hours

1,656 €

Fragaria

About

What is it?

Fragaria is an OS X Cocoa syntax colouring NSTextView implemented within a framework named MGSFragaria. It supports a wide range of programming languages and includes preference panel support. The MGSFragaria framework now properly supports both traditional reference counting memory management and garbage collection.

Where can I see it in use

You can see Fragaria used in the following projects and products:

  • Appium Recorder : Appium is an open source, cross-platform test automation tool for native and hybrid mobile apps. (repo).
  • cocoa-rest-client A native OS X cocoa application for testing HTTP endpoints.
  • CocosBuilder. CocosBuilder is a free tool (released under MIT-licence) for rapidly developing games and apps. (repo)
  • Cocoduino is an IDE for the Arduino platform written in native Cocoa.
  • KosmicTask is a multi (20+) language scripting environment for OS X that features script editing, network sharing, remote execution, and file processing.
  • nib2objc This utility converts NIB files (or XIB ones) into Objective-C code If you use Fragaria in your app and want it added to the list just let us know or edit the README.

    Features

    Most features are accessed via the framework preferences.

  • Configurable syntax colouring
  • Configurable font type, size and colour.
  • Invisible character display
  • Line numbering
  • Brace matching and auto insertion
  • Page guide
  • Simple word auto complete
  • Tab and indent control
  • Line wrapping

7 hours

1,656 €

Work with Kubernator

About

About  

Kubernator is an alternative Kubernetes UI. In contrast to high-level Kubernetes Dashboard, it provides low-level control and clean view on all objects in a cluster with the ability to create new ones, edit and resolve conflicts. As an entirely client-side app (like kubectl), it doesn't require any backend except Kubernetes API server itself, and also respects cluster's access control.

Content

  • Catalog

  • Navigation Tree

  • Extensive Caching

  • Multiple API Versions

  • Tabs

  • Copying Objects

  • Actions Bar

  • Keyboard Shortcuts

  • Most frequent actions have associated keyboard shortcuts.

  • Diff Editor

  • RBAC Viewer

  • Controls

  • Graph

  • Notifications

 


7 hours

1,656 €

Learn ClusterKit

About

ClusterKit is an elegant and efficiant clustering controller for maps. Its flexible architecture make it very customizable, you can use your own algorithm and even your own map provider.

Features

  • Native supports of MapKit, GoogleMaps, Mapbox and YandexMapKit.
  • Comes with 2 clustering algorithms, a Grid Based Algorithm and a Non Hierarchical Distance Based Algorithm.
  • Annotations are stored in a QuadTree for efficient region queries.
  • Cluster center can be switched to Centroid, Nearest Centroid, Bottom.
  • Handles pin selection as well as drag and dropping.
  • Written in Objective-C with full Swift interop support. MapKit GoogleMaps Mapbox

7 hours

1,656 €

PlatyPS

About

PlatyPS provides a way to:

  • Write PowerShell External Help in Markdown
  • Generate markdown help (example) for your existing modules
  • Keep markdown help up-to-date with your code Markdown help docs can be generated from old external help files (also known as MAML-xml help), the command objects (reflection), or both. PlatyPS can also generate cab files for Update-Help.

    Why?

    Traditionally PowerShell external help files have been authored by hand or using complex tool chains and rendered as MAML XML for use as console help. MAML is cumbersome to edit by hand, and common tools and editors don't support it for complex scenarios like they do with Markdown. PlatyPS is provided as a solution for allow documenting PowerShell help in any editor or tool that supports Markdown. An additional challenge PlatyPS tackles, is to handle PowerShell documentation for complex scenarios (e.g. very large, closed source, and/or C#/binary modules) where it may be desirable to have documentation abstracted away from the codebase. PlatyPS does not need source access to generate documentation. Markdown is designed to be human-readable, without rendering. This makes writing and editing easy and efficient. Many editors support it (Visual Studio Code, Sublime Text, etc), and many tools and collaboration platforms (GitHub, Visual Studio Online) render the Markdown nicely.

    Common setups

    There are 2 common setups that are used:

    1. Use markdown as the source of truth and remove other types of help.
    2. Keep comment based help as the source of truth and periodically generate markdown for web-site publishing. They both have advantages and use-cases, you should decide what's right for you. There is slight preference toward number 1 (markdown as the source).

      Quick start

  • Install platyPS module from the PowerShell Gallery:

7 hours

1,656 €

Nohm

About

Nohm

Description

Nohm is an object relational mapper (ORM) written for node.js and redis written in Typescript.

Features

Allows using the same code for client validations that is used for backend. Includes filtering which validations are shared. With this you can do things like socket connections to get live updates from stored models.
Since it uses redis PUBSUB you can scale your node app and clients can connect to separate node app instances but will still get the same live updates. nohm is written in Typescript and thus provides first-class typings for most things, including the option to type your model properties. This means if you use Typescript you don't have to remember every single property name of each model anymore, your IDE can tell you. This is a double-edged sword. Usually ORMs describe relations statically and you have to do database changes before you can add new relations.
In nohm all relations are defined and used at run-time, since there are no schemas stored in the database.


7 hours

1,656 €

Elix

About

Elix is a community-driven collection of high-quality web components for common user interface patterns. Most applications make use of common, general-purpose user interface patterns such lists, menus, dialogs, carousels, and so on. Such patterns can be efficiently implemented and packaged as web components. Their modular nature lets you easily incorporate web components into your web application, and their standard definition ensures good results across browsers. This arrangement permits a beneficial economy of scale, as common patterns only have to be implemented once. But that is not to say that its easy to develop general-purpose user interface patterns as solid components. To the contrary, implementing even simple patterns with a very high degree of quality can entail substantial complexity. For that reason, the Elix project believes that implementing high-quality, general-purpose components is best done as a community effort. This spreads the cost of creating the components across organizations, and ensures that the resulting components satisfy a broad range of concerns and can be used in many contexts. For full details and demos, see the Elix documentation.

Quick start

Plain HTML and JavaScript

Add the Elix package to your package.json: { "dependencies": { "elix": "" } } Then run npm install. We generally recommend locking your package.json to a fixed Elix version number (1.0.0 rather than ^1.0.0 or 1.x, for example). See more at Versioning. In markup, you can then reference the components you need:

Alternatively, in JavaScript, you can directly import components: import Carousel from "elix/define/Carousel.js"; const carousel = new Carousel(); // Add images, etc., to the carousel. const image1 = new Image(); image1.src = "image1.jpg"; carousel.append(image1); // Add the carousel to the page. document.body.append(carousel); The Elix project itself requires no build step. You are free to use your preferred tools to bundle the Elix modules for better network performance. You can try out the plain HTML and JavaScript project on your own machine.

React

See the sample React project showing how to use Elix components in a React application.

TypeScript

See the sample TypeScript project showing how to use Elix components in a TypeScript application. Elix includes TypeScript declaration files so that you can confirm that interactions with Elix components are type safe.

Core principles

Versioning

Elix is an ambitious attempt to deconstruct complex user interface elements into constituent parts at various levels of abstraction. We regularly feel like the project is breaking new ground at the frontier of front-end design and implementation. That can be exciting, but also means that promising implementation strategies will sometimes turn out to be dead ends. Moving forward will often entail breaking changes.


7 hours

1,656 €

Gocqlx

About

  GocqlX makes working with Scylla easy and less error-prone. Its inspired by Sqlx, a tool for working with SQL databases, but it goes beyond what Sqlx provides.

Features

  • Binding query parameters from struct fields, map, or both
  • Scanning query results into structs based on field names
  • Convenient functions for common tasks such as loading a single row into a struct or all rows into a slice (list) of structs
  • Making any struct a UDT without implementing marshalling functions
  • GocqlX is fast. Its performance is comparable to raw driver. You can find some benchmarks here. Subpackages provide additional functionality:
  • CQL query builder (package qb)
  • CRUD operations based on table model (package table)
  • Database migrations (package migrate)

7 hours

1,656 €

Helm Operator

About

Helm Operator

The Helm Operator is a Kubernetes operator, allowing one to declaratively manage Helm chart releases. Combined with releases in a GitOps manner, but the usage of Flux is not a strict requirement. The desired state of a Helm release is described through a Kubernetes Custom Resource named HelmRelease. Based on the creation, mutation or removal of a HelmRelease resource in the cluster, Helm actions are performed by the operator.

Helm Operator features

  • Declarative install, upgrade, and delete of Helm releases
  • Pulls chart from any chart source;
    • Public or private Helm repositories over HTTP/S
    • Public or private Git repositories over HTTPS or SSH
    • Any other public or private chart source using one of the available
  • Allows Helm values to be specified;
    • In-line in the HelmRelease resource
    • In (external) sources, e.g. ConfigMap and Secret resources, or a (local) URL
  • Automated purging on release install failures
  • Automated (optional) rollback on upgrade failures
  • Automated (optional) helm test gating of installs and upgrades.
  • Automated image upgrades using Flux
  • Automated (configurable) chart dependency updates for Helm charts from Git sources on install or upgrade
  • Detection and recovery from Helm storage mutations (e.g. a manual Helm release that was made but conflicts with the declared configuration for the release)
  • Parallel and scalable processing of different HelmRelease resources

7 hours

1,656 €

Discover PruneCluster

About

PruneCluster is a fast and realtime marker clustering library. Example 1: 150 000 randomly moving markers. Example 2: Realtime clusters of tweets. It's working with Leaflet as an alternative to Leaflet.markercluster.

The library is designed for large datasets or live situations. The memory consumption is kept low and the library is fast on mobile devices, thanks to a new algorithm inspired by collision detection in physical engines.

Features

Realtime

The clusters can be updated in realtime. It's perfect for live datasets or datasets you want to filter at runtime.

Fast

Number of markers|First step|Update (low zoom level)|Update (high zoom level) These values are tested with random positions, on a recent laptop, using Chrome 38. One half of markers is moving randomly and the other half is static. It is also fast enough for mobile devices. If you prefer real world data, the 50k Leaflet.markercluster example is computed in 60ms (original).

Weight

You can specify the weight of each marker. For example, you may want to add more importance to a marker representing an incident, than a marker representing a tweet.

Categories

You can specify a category for the markers. Then a small object representing the number of markers for each category is attached to the clusters. This way, you can create cluster icons adapted to their content.

Dynamic cluster size

The size of a cluster can be adjusted on the fly (Example)

Filtering

The markers can be filtered easily with no performance cost.


7 hours

1,656 €

Explore tiny utf8

About

Lightweight C++11 library for embedding Unicode

This project was moved to and is not being maintained on sourceforge anymore.


7 hours

1,656 €

Basics of ArduinoRCLib

About

Library for Arduino based R/C equipment

A library containing functions for building Arduino based R/C equipment like transmitters, receivers and flight controllers.


7 hours

1,656 €

Fundamentals of FPDF net

About

FPDF.net is a VB.net class which allows to generate PDF files, F from FPDF stands for Free: you may use it for any kind of usage and modify it to suit your needs. This is the port of FPDF ( ) to vb.net.


7 hours

1,656 €

Work around with Qt Modbus TcpIp

About

A class to manage Modbus frames and another to make a Modbus server. Both classes are fully portable. An example of a modbus server is given. The code is very simple and comprehensive. Note ; Qt includes some classes related to Modbus since Qt 5.6.


7 hours

1,656 €

Discover SNMPpp

About

Easy-to-use C++ library for various SNMP tasks

Easy-to-use C++ library for various SNMP tasks. Is meant to be used as a C++ wrapper to net-snmp. Requires netsnmp-dev.


7 hours

1,656 €

Learn libxlsxwriter for Clarion

About

Wrapper of C library

Wrapper for Clarion based on C library (). Write xlsx files without Excel! Data, formatting, charts, filters and more. No extra dependencies like .NET Frameworks and so on. Clarion 6 or higher supported


7 hours

1,656 €

Basics of Coronis SDK

About

Set of module for data processing of wireless device

The goal is to create a leading “Set of software libraries for data processing of wireless device based on Coronis platform“. These libraries will run on all major platforms (embedded and desktop) and provide services for data processing through generic APIs. Keywords: Coronis, Wavenis, API, Plugin, Wireless, Waveport, Wavecard, Profile, Java, C, C++, C#


7 hours

1,656 €

Fundamentals of OpenCV CUDA Binaries

About

OpenCV Pre-built CUDA binaries

opencvcuda-release opencvcuda-debug 3 Builds now available as nuget packages : - Package for the default Windows x64 build available on opencv.org - Package for Windows x64 Visual Studio 2015 for the contrib and vtk modules built with AVX, SSE & OpenGL support. - - Packages for Release and Debug configurations (due to file size limitations on nuget.org) built with CUDA Toolkit 7.0.0 targeting architectures 2.0, 2.1, 3.0, 3.5, 3.7, 5.0, 5.2 suitable for Visual Studio 2013.


7 hours

1,656 €

Discover NetLink Sockets C Library

About

Networking/Socket C++ Library.

NetLink Sockets: Networking C++ Library. Probably the easiest socket C++ library. 


7 hours

1,656 €


Is learning Snippets and Libraries hard?


In the field of Snippets and Libraries learning from a live instructor-led and hand-on training courses would make a big difference as compared with watching a video learning materials. Participants must maintain focus and interact with the trainer for questions and concerns. In Qwikcourse, trainers and participants uses DaDesktop , a cloud desktop environment designed for instructors and students who wish to carry out interactive, hands-on training from distant physical locations.


Is Snippets and Libraries a good field?


For now, there are tremendous work opportunities for various IT fields. Most of the courses in Snippets and Libraries is a great source of IT learning with hands-on training and experience which could be a great contribution to your portfolio.



Snippets and Libraries Online Courses, Snippets and Libraries Training, Snippets and Libraries Instructor-led, Snippets and Libraries Live Trainer, Snippets and Libraries Trainer, Snippets and Libraries Online Lesson, Snippets and Libraries Education