zipstream.py is a zip archive generator based on zipfile.py. It was created to generate a zip file generator for streaming. This is beneficial for when you want to provide a downloadable archive of a large collection of regular files, which would be infeasible to generate the archive prior to downloading or of a very large file that you do not want to store entirely on disk or on memory.

This package provides Python implementation of ASDF - a proposed next generation interchange format for scientific data. ASDF aims to exist in the same middle ground that made FITS so successful, by being a hybrid text and binary format: containing human editable metadata for interchange, and raw binary data that is fast to load and use. Unlike FITS, the metadata is highly structured and is designed up-front for extensibility.

gcvb (generate compute validate benchmark) is a Python 3 module aiming at facilitating non-regression, validation and benchmarking of simulation codes. gcvb is not a complete tool of continuous integration (CI). It is rather a component of the testing part of a CI workflow. It can compare the different metrics of your computation with references that can be a file, depends of the 'configuration' or are absolute. This is the fork of Marek Felšöci.

This package provides pydantic typing support for astropy unit types. Can be used to de(serialize) astropy quantities and units.

Types:

• AstroPydanticUnit: an overlay for astropy.units.UnitBase (all unit types).

• AstroPydanticQuantity: an overlay for astropy.units.Quantity, including array types.

• AstroPydanticTime: an overlay for astropy.time.Time.

• AstroPydanticICRS: an overlay for astropy.coordinates.ICRS and astropy.coordinates.SkyCoord.

The purpose of the ufonormalizer command is to provide a standard formatting so that updates to UFO data can be usefully versioned. Examples of formatting applied by ufoNormalizer include:

• Changing floating-point numbers to integers where it doesn't alter the value (e.g. x="95.0" becomes x="95")

• Rounding floating-point numbers to 10 digits

• Formatting XML with tabs rather than spaces.

This package implements a functionality of AI-powered automated pipeline for lens modeling, with lenstronomy as the modeling engine.

Features:

• AI-automated forward modeling for large samples of galaxy-scale lenses

• flexible: supports both fully automated and semi-automated (with user tweaks) modes

• multi-band lens modeling made simple

• supports both galaxy–galaxy and galaxy–quasar systems

• effortless syncing between local machines and High-Performance Computing Cluster

This is a set of functions for processing raw scDam&T-seq data. scDam&T-seq is a method to simultaneously measure protein-DNA interactions and transcription from single cells (Rooijers et al., 2019). It combines a DamID-based method to measure protein-DNA interactions and an adaptation of CEL-Seq to measure transcription. The starting point of the workflow is raw sequencing data and the end result are tables of UMI-unique DamID and CEL-Seq counts.

Pandoc is a powerful utility to transform various input formats into a wide range of output formats. To alter the exported output document, Pandoc allows the usage of filters, which are pipes that read a JSON serialization of the Pandoc AST from stdin, transform it in some way, and write it to stdout. It allows therefore to alter the processing of Pandoc's supported input formats, for instance one can add new syntax elements to markdown, etc.

This package provides Python bindings.

Deterministically encode JSON.

• Encodes objects and arrays as RFC 7159 JSON.

• Sorts object keys so that you get the same result each time.

• Has no insignificant whitespace to make the output as small as possible.

• Escapes only the characters that must be escaped, U+0000 to U+0019 / U+0022 / U+0056, to keep the output as small as possible.

• Uses the shortest escape sequence for each escaped character.

• Encodes the JSON as UTF-8.

• Can encode frozendict immutable dictionaries.

This package implements a multi-dimensional spatial image data structure for scientific Python.

To facilitate:

• Multi-scale processing and analysis

• Registration

• Resampling

• Subregion parallel processing

• Coupling with meshes, point sets, and annotations

with scientific images, which are typically multi-dimensional with anisotropic sampling, this package provides a spatial-image data structure. In addition to an N-dimensional array of pixel values, spatial metadata defines the location of the pixel sampling grid in space time. It also labels the array dimensions. This metadata is easily utilized and carried through image processing pipelines.

TeNPy is a Python library for the simulation of strongly correlated quantum systems with tensor networks.

The philosophy of this library is to get a new balance of a good readability and usability for new-comers, and at the same time powerful algorithms and fast development of new algorithms for experts. For good readability, we include an extensive documentation next to the code, both in Python doc strings and separately as "user guides", as well as simple example codes and even toy codes, which just demonstrate various algorithms (like TEBD and DMRG) in ~100 lines per file.

The spectral-cube package provides an easy way to read, manipulate, analyze, and write data cubes with two positional dimensions and one spectral dimension, optionally with Stokes parameters.

It provides the following main features:

• A uniform interface to spectral cubes, robust to the wide range of conventions of axis order, spatial projections, and spectral units that exist in the wild.

• Easy extraction of cube sub-regions using physical coordinates.

• Ability to easily create, combine, and apply masks to datasets.

• Basic summary statistic methods like moments and array aggregates.

• Designed to work with datasets too large to load into memory.

This package provides the following PyHamcrest test matchers, that enable matching a protocol buffer message:

equals_proto

Test the argument equals the given protobuf message.

approximately

Test the argument equals the given protobuf message, while comparing any float field using approximation.

ignoring_field_paths

Test the argument equals the given protobuf message, while ignoring those fields specified in the field paths.

ignoring_repeated_field_ordering

Test the argument equals the given protobuf message, ignoring the ordering of any repeated field.

partially

Test the argument partially equals the given protobuf message, i.e. if a field is in the argument but not in the expected message, it's ignored in the comparison.

This package provides a URI Normalization function with following features:

• take care of IDN domains

• always provide the URI scheme in lowercase characters

• always provide the host, if any, in lowercase characters

• only perform percent-encoding where it is essential

• always use uppercase A-through-F characters when percent-encoding

• prevent dot-segments appearing in non-relative URI paths

• for schemes that define a default authority, use an empty authority if the default is desired

• for schemes that define an empty path to be equivalent to a path of /, use /

• for schemes that define a port, use an empty port if the default is desired

• all portions of the URI must be utf-8 encoded NFC from Unicode strings

PyCryptodome is a self-contained Python package of low-level cryptographic primitives. It's not a wrapper to a separate C library like OpenSSL. To the largest possible extent, algorithms are implemented in pure Python. Only the pieces that are extremely critical to performance (e.g., block ciphers) are implemented as C extensions.

You are expected to have a solid understanding of cryptography and security engineering to successfully use these primitives. You must also be able to recognize that some are obsolete (e.g., TDES) or even insecure (RC4).

It provides many enhancements over the last release of PyCrypto (2.6.1):

• Authenticated encryption modes (GCM, CCM, EAX, SIV, OCB)

• Accelerated AES on Intel platforms via AES-NI

• First-class support for PyPy

• Elliptic curves cryptography (NIST P-256 curve only)

• Better and more compact API (nonce and iv attributes for ciphers, automatic generation of random nonces and IVs, simplified CTR cipher mode, and more)

• SHA-3 (including SHAKE XOFs) and BLAKE2 hash algorithms

• Salsa20 and ChaCha20 stream ciphers

• scrypt and HKDF

• Deterministic (EC)DSA

• Password-protected PKCS#8 key containers

• Shamir’s Secret Sharing scheme

• Random numbers get sourced directly from the OS (and not from a CSPRNG in userspace)

• Cleaner RSA and DSA key generation (largely based on FIPS 186-4)

• Major clean-ups and simplification of the code base

PyCryptodomex is the stand-alone version of PyCryptodome that no longer provides drop-in compatibility with PyCrypto.

This package provides a parser based on lib2to3 producing docspec data from Python source code.

subprocess-tee.

Ansible compatibility goodies.

Zope Component Architecture

Enable installed pytest plugins

Typing stubs for requests

Typing stubs for aiofiles

FFMPEG wrapper for Python