Serpent provides ast.literal_eval()-compatible object tree serialization. It serializes an object tree into bytes (an utf-8 encoded string) that can be decoded and then passed as-is to ast.literal_eval() to rebuild the original object tree.

Because only safe literals are encoded, it is safe to send serpent data to other machines, such as over the network.

This library implements a simple lossless compression scheme adapted to time-dependent high-frequency, high-dimensional signals. It is being developed within the International Brain Laboratory with the aim of being the compression library used for all large-scale electrophysiological recordings based on Neuropixels. The signals are typically recorded at 30 kHz and 10 bit depth, and contain several hundreds of channels.

The COde-independent Organized LEns STandard (COOLEST) defines a set of conventions to be shared across the strong lensing community, in order to consistently store, share and improve lens modeling analyses. In short, this project provides tools to manipulate lens models as a single, human-readable JSON template file alongside Python routines for visualizing and comparing lens models possibly obtained from different modeling codes.

iminuit is a Jupyter-friendly Python interface for the Minuit2 C++ library maintained by CERN's ROOT team.

Minuit was designed to optimize statistical cost functions, for maximum-likelihood and least-squares fits. It provides the best-fit parameters and error estimates from likelihood profile analysis.

Optionally, Iminuit supports SciPy minimizers as alternatives to Minuit's MIGRAD algorithm and Numba accelerated functions.

This is a backport of the standard library typing module to Python versions older than 3.5. Typing defines a standard notation for Python function and variable type annotations. The notation can be used for documenting code in a concise, standard format, and it has been designed to also be used by static and runtime type checkers, static analyzers, IDEs and other tools.

Vulture finds unused code in Python programs. This is useful for cleaning up and finding errors in large code bases. If you run Vulture on both your library and test suite you can find untested code. Due to Python's dynamic nature, static code analyzers like Vulture are likely to miss some dead code. Also, code that is only called implicitly may be reported as unused.

PyVista is...

• Pythonic VTK: a high-level API to the Visualization Toolkit (VTK);

• mesh data structures and filtering methods for spatial datasets;

• 3D plotting made simple and built for large/complex data geometries.

This package provides a Pythonic, well-documented interface exposing VTK's powerful visualization backend to facilitate rapid prototyping, analysis, and visual integration of spatially referenced datasets.

This package provides CLI tool and Python library parallel file downloader using asyncio. parfive can handle downloading multiple files in parallel as well as downloading each file in a number of chunks.

asciicast demo of parfive parfive works by creating a downloader object, appending files to it and then running the download. parfive has a synchronous API, but uses asyncio to parallelise downloading the files.

Plaster is a loader interface around multiple config file formats. It exists to define a common API for applications to use when they wish to load configuration. The library itself does not aim to handle anything except a basic API that applications may use to find and load configuration settings. Any specific constraints should be implemented in a pluggable loader which can be registered via an entrypoint.

This package provides a Python/C(++) implementation of Hartigan & Hartigan's dip test for unimodality.

The dip test measures multimodality in a sample by the maximum difference, over all sample points, between the empirical distribution function, and the unimodal distribution function that minimizes that maximum difference. Other than unimodality, it makes no further assumptions about the form of the null distribution.

Pympler is a development tool to measure, monitor and analyze the memory behavior of Python objects in a running Python application.

By pympling a Python application, detailed insight in the size and the lifetime of Python objects can be obtained. Undesirable or unexpected runtime behavior like memory bloat and other pymples can easily be identified.

A web profiling frontend exposes process statistics, garbage visualisation and class tracker statistics.

This Python package implements Ted Dunning's t-digest data structure, which is designed around computing accurate estimates such as percentiles, quantiles and trimmed means from streaming or distributed data. Two t-digests can be added, making the data structure ideal for map-reduce settings, and can be serialized into much less than 10 kB, instead of storing the entire list of data.

This package provides Kullback-Leibler projections for Bayesian model selection. Variable selection refers to the process of identifying the most relevant variables in a model from a larger set of predictors. When performing this process, we usually assume that variables contribute unevenly to the outcome, and we want to identify the most important ones. Sometimes we also care about the order in which variables are included in the model.

This package provides some extra widgets for PyQt/PySide:

• Multi-handle slider for float values

• Spinbox with arbitrarily large integers

• Magnitude combined with unit dropdown

• Label that will elide text

• Searchable ComboBox populated from Enum

• Searchable List

• Searchable Tree

• Color ComboBox

• Colormap ComboBox

• Toggle switch

• Collapsible widget to hide and unhide child widgets

• Flow layout

CoolBox is a toolkit for visual analysis of genomics data. It aims to be highly compatible with the Python ecosystem, easy to use and highly customizable with a well-designed user interface. It can be used in various visualization situations, for example, to produce high-quality genome track plots or fetch common used genomic data files with a Python script or command line, interactively explore genomic data within Jupyter environment or web browser.

This package can create project files for supported tools and run them in batch or GUI mode. All EDA tools such as Icarus, Yosys, ModelSim, Vivado, Verilator, GHDL, Quartus etc get input HDL files (Verilog and VHDL) and some tool-specific files (constraint files,memory initialization files, IP description files etc). Together with the files, perhaps a couple of Verilog `defines, some top-level parameters/generics or some tool-specific options are set.

The socksio Python module is a client-side sans-I/O SOCKS proxy implementation. It supports SOCKS4, SOCKS4A, and SOCKS5. socksio is a sans-I/O library similar to h11 or h2; this means the library itself does not handle the actual sending of the bytes through the network, it only deals with the implementation details of the SOCKS protocols. It can be paired with any I/O library.

This package implements a functionality to produce map based simulations for the Simons Observatory or other CMB experiments. It creates simulated maps in HEALPix and CAR pixelization based on:

• foreground models included in PySM

• custom foregrounds models from the so_pysm_models package

• precomputed Cosmic Microwave Background simulations

• noise simulations based on expected performance and simulated hitmaps

• effect of gaussian beam convolution

PeachPy is a Python framework for writing high-performance assembly kernels. PeachPy aims to simplify writing optimized assembly kernels while preserving all optimization opportunities of traditional assembly.

PeachPy can generate ELF, MS-COFF, Mach-O object files, and assembly listings for the Go language tool chain; it adapts to different calling conventions and application binary interfaces (ABIs); it takes care of register allocation; it supports x86_64 instructions up to AVX-512 and SHA.

HDBSCAN - Hierarchical Density-Based Spatial Clustering of Applications with Noise. Performs DBSCAN over varying epsilon values and integrates the result to find a clustering that gives the best stability over epsilon. This allows HDBSCAN to find clusters of varying densities (unlike DBSCAN), and be more robust to parameter selection. HDBSCAN is ideal for exploratory data analysis; it's a fast and robust algorithm that you can trust to return meaningful clusters (if there are any).

Pytools is a bag of things that are ``missing'' from the Python standard library:

• small helper functions such as len_iterable, argmin, tuple generation, permutation generation, ASCII table pretty printing, GvR's monkeypatch_xxx hack, the elusive flatten, and much more.

• Michele Simionato's decorator module

• A time-series logging module, pytools.log.

• Batch job submission, pytools.batchjob.

• A lexer, pytools.lex.

This package provides wrappers for the commands of Python 3.x such that they can also be invoked under their usual names---e.g., python instead of python3 or pip instead of pip3.

To function properly, this package should not be installed together with the python package: this package uses the python package as a propagated input, so installing this package already makes both the versioned and the unversioned commands available.

Netcdf4-python is a Python interface to the netCDF C library. netCDF version 4 has many features not found in earlier versions of the library and is implemented on top of HDF5. This module can read and write files in both the new netCDF 4 and the old netCDF 3 format, and can create files that are readable by HDF5 clients. The API is modelled after Scientific.IO.NetCDF, and should be familiar to users of that module.

Python implementation of Parker wind models for planetary atmospheres. p-winds produces simplified, 1-D models of the upper atmosphere of a planet, and perform radiative transfer to calculate observable spectral signatures.

The scalable implementation of 1D models allows for atmospheric retrievals to calculate atmospheric escape rates and temperatures. In addition, the modular implementation allows for a smooth plugging-in of more complex descriptions to forward model their corresponding spectral signatures (e.g., self-consistent or 3D models).