Signal messaging library for Python using Presage (Rust).
Fast serialization library for Clojure
Clojure's rich data types are awesome. And its reader allows you to take your data just about anywhere. But the reader can be painfully slow when you've got a lot of data to crunch (like when you're serializing to a database).
Nippy is a mature, high-performance drop-in alternative to the reader.
It is used at scale by Carmine, Faraday, PigPen, Onyx, XTDB, Datalevin, and others.
Why Nippy?
- Small, simple pure-Clojure library
- Terrific performance: the best for Clojure that I'm aware of
- Comprehensive support for all standard data types
- Easily extendable to custom data types
- Robust test suite incl. coverage of every supported type
- Mature and widely used in production for 12+ years
- Optional auto fallback to Java Serializable for safe types
- Optional auto fallback to Clojure Reader (including tagged literals)
- Optional smart compression with LZ4 or Zstandard
- Optional encryption with AES128
- Tools for easy + robust integration into 3rd-party libraries, etc.
- Powerful thaw transducer for flexible data inspection and transformation
The claypoole library provides threadpool-based parallel versions of Clojure functions such as pmap, future, and for.
A Clojure/Datomic library for idempotently transacting datoms (norms) into your database – be they schema, data, or otherwise.
In the simplest sense, conformity allows you to write migrations and ensure that they run once and only once.
In a more general sense, conformity allows you to declare expectations (in the form of norms) about the state of your database, and enforce those idempotently without repeatedly transacting schema, required data, etc.
Graph is a simple, declarative abstraction to express compositional structure.
Declarative means that we should explicitly list a system’s components and dependencies in a way that is accessible to our tooling. This solves the issues of the previous section, enabling abstractions over a system’s components as well as reasoning about the composition as a whole. Of course, this idea is not new; for example, it is the basis of graph computation frameworks like Pregel, Dryad, and Storm, and existing libraries for system composition such as react.
Our primary objective in Graph is to distill this idea to its simplest, most idiomatic expression in Clojure, our language of choice. Concretely, a Graph is just a Clojure map of functions that can depend on the outputs of other functions. Because Graphs are just ordinary data, we can manipulate them for free using our favorite existing tools, making Graphs trivially easy to create, modify, run, reason about, test, and build upon. Put simply, Graph is an [FCA][swe] for composition.
It is better to have 100 functions operate on one data structure than 10
functions on 10 data structures.
-- Alan PerlisAs a first attempt in this direction, we could rewrite our stats example as a Clojure map, turning let variables into keywords and wrapping each of the corresponding value expressions in anonymous functions.
This gets us 90% of the way there. The individual components of the computation are now explicit, but the dependency information is still missing. For instance, there’s no way for our tools to know that the m in the arguments to the :v function refers to the mean computed in the second step of the graph – after compilation, it’s just the first argument to an anonymous function.
- GitHub - plumatic/plumbing: Prismatic's Clojure(Script) utility belt · GitHub
- Plumbing 0.4.0 API documentation
A ClojureScript DOM manipulation and event library.
A fast library for rendering HTML in Clojure.
Membrane provides all the tools you need to build a user interface. While all the pieces are built to work together, each piece is optional or can be mixed and matched with other implementations. For example, you could use your favorite UI framework and the other layers to reach another platform. Alternatively, you could provide your own ncurses graphics backend and leverage the ui framework and graphics model.
The three main pieces are:
- A UI framework, membrane.component, that provides state management for GUIs
- A platform agnostic model for graphics and events
- Multiple graphics backends that provide concrete implementations for #2
For membrane to run on a platform, the only requirements are:
- Drawing implementations for graphical primitives like shapes, text, and images
- An event loop that forwards events (eg. mouse clicks, key presses) to membrane and repaints
A small library for explicit, intentful configuration.
- [[aero/aero "1.1.6"] - Clojars](https:// .org/aero)
Typer is a library for building CLI applications that users will love using and developers will love creating. Based on Python type hints.
It's also a command line tool to run scripts, automatically converting them to CLI applications.
The key features are:
- Intuitive to write: Great editor support. Completion everywhere. Less time debugging. Designed to be easy to use and learn. Less time reading docs.
- Easy to use: It's easy to use for the final users. Automatic help, and automatic completion for all shells.
- Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
- Start simple: The simplest example adds only 2 lines of code to your app: 1 import, 1 function call.
- Grow large: Grow in complexity as much as you want, create arbitrarily complex trees of commands and groups of subcommands, with options and arguments.
- Run scripts: Typer includes a typer command/program that you can use to run scripts, automatically converting them to CLIs, even if they don't use Typer internally.
Ansible Runner is a tool and python library that helps when interfacing with Ansible directly or as part of another system whether that be through a container image interface, as a standalone tool, or as a Python module that can be imported. The goal is to provide a stable and consistent interface abstraction to Ansible. This allows Ansible to be embedded into other systems that don’t want to manage the complexities of the interface on their own (such as CI/CD platforms, Jenkins, or other automated tooling).
Topics
Casbin is a powerful and efficient open-source access control library that supports various access control models for enforcing authorization across the board.
Enforcing a set of rules is as simple as listing subjects, objects, and the desired allowed action (or any other format as per your needs) in a policy file. This is synonymous across all flows in which Casbin is used. The developer/administrator has complete control over the layout, execution, and conditions for authorization, which are set via the model file. Casbin provides an Enforcer for validating an incoming request based on the policy and model files given to the Enforcer.
Sparselizard (GNU GPLv2+, Copyright (C) 2020-2021 A. Halbach, Copyright (C) 2018-2019 A. Halbach, IMEC, Copyright (C) 2017 A. Halbach and C. Geuzaine, University of Liege) is a high-performance, multiphysics, hp-adaptive, open source C++ finite element library running on Linux, Mac and Windows. It is carefully validated against analytical solutions, third party software and lab measurements. General high-performance domain decomposition methods are available for large-scale simulations on computing clusters (contact Quanscient for commercial applications). Efficient conformal adaptive mesh refinement (AMR) is provided for 3D, 2D and 1D problems. A fast algorithm for mesh-to-mesh interpolation and a general implementation of the mortar finite element method allow to easily work with non-matching meshes and provide general periodic conditions. FEM simulations can be weakly or strongly coupled to lumped electric circuits. Sparselizard can handle a general set of problems in 3D, 2D axisymmetric, 2D and 1D such as mechanical (anisotropic elasticity, geometric nonlinearity, buckling, contact, crystal orientation), fluid flow (laminar, creeping, incompressible, compressible), stabilized advection-diffusion, nonlinear acoustic, thermal, thermoacoustic, fluid-structure interaction, electric, magnetic, electromagnetic, piezoelectric, superconductor,... problems with a transient, (multi)harmonic or damped/undamped eigenmode analysis. A massive amount of data can be stored for delayed, remote post-processing thanks to the ultra compact .slz data format. Problems with several millions of unknowns in 3D and several tens of millions of unknowns in 2D have been solved within minutes on up to 32 cores/64 threads (see report). Some built-in geometry definition and meshing tools are also provided.
This part of the documentation covers all the interfaces of Requests. For parts where Requests depends on external libraries, we document the most important right here and provide links to the canonical documentation.
Requests is an elegant and simple HTTP library for Python, built for human beings.
Requests allows you to send HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling are 100% automatic, thanks to urllib3.
Beloved Features:
- Requests is ready for today’s web.
- Keep-Alive & Connection Pooling
- International Domains and URLs
- Sessions with Cookie Persistence
- Browser-style SSL Verification
- Automatic Content Decoding
- Basic/Digest Authentication
- Elegant Key/Value Cookies
- Automatic Decompression
- Unicode Response Bodies
- HTTP(S) Proxy Support
- Multipart File Uploads
- Streaming Downloads
- Connection Timeouts
- Chunked Requests
- .netrc Support
Requests officially supports Python 2.7 & 3.6+, and runs great on PyPy.
i3ipc-python is a library for controlling i3 window manager and sway. i3 users can use this library to create their own plugin scripts to customize their desktop or integrate i3 into other applications. With this library, you can query the state of the window manager, listen to events, and send commands to i3 to perform window manager actions such as focusing or closing windows.
The main entry point into the features of the library is the Connection class. This class manages a Unix socket connection to the ipc interface exposed by the window manager. By default, the Connection will attempt to connect to the running instance of i3 by using information present in the environment or the running X11 display.
PyOTP is a Python library for generating and verifying one-time passwords. It can be used to implement two-factor (2FA) or multi-factor (MFA) authentication methods in web applications and in other systems that require users to log in.
Open MFA standards are defined in RFC 4226 (HOTP: An HMAC-Based One-Time Password Algorithm) and in RFC 6238 (TOTP: Time-Based One-Time Password Algorithm). PyOTP implements server-side support for both of these standards. Client-side support can be enabled by sending authentication codes to users over SMS or email (HOTP) or, for TOTP, by instructing users to use Google Authenticator, Authy, or another compatible app. Users can set up auth tokens in their apps easily by using their phone camera to scan otpauth:// QR codes provided by PyOTP.
Mitogen is a Python library for writing distributed self-replicating programs.
There is no requirement for installing packages, copying files around, writing shell snippets, upfront configuration, or providing any secondary link to a remote machine aside from an SSH connection. Due to its origins for use in managing potentially damaged infrastructure, the remote machine need not even have free disk space or a writeable filesystem.
It is not intended as a generic RPC framework; the goal is to provide a robust and efficient low-level API on which tools like Salt, Ansible, or Fabric can be built, and while the API is quite friendly and comparable to Fabric, ultimately it is not intended for direct use by consumer software.
The focus is to centralize and perfect the intricate dance required to run Python code safely and efficiently on a remote machine, while avoiding temporary files or large chunks of error-prone shell scripts, and supporting common privilege escalation techniques like sudo, potentially in combination with exotic connection methods such as WMI, telnet, or console-over-IPMI.
GitPython is a python library used to interact with git repositories, high-level like git-porcelain, or low-level like git-plumbing.
It provides abstractions of git objects for easy access of repository data, and additionally allows you to access the git repository more directly using either a pure python implementation, or the faster, but more resource intensive git command implementation.
The object database implementation is optimized for handling large quantities of objects and large datasets, which is achieved by using low-level structures and data streaming.
This is the Dulwich project.
It aims to provide an interface to git repos (both local and remote) that doesn’t call out to git directly but instead uses pure Python.