CellTypist is an automated cell type annotation tool for scRNA-seq datasets on the basis of logistic regression classifiers optimised by the stochastic gradient descent algorithm. CellTypist allows for cell prediction using either built-in (with a current focus on immune sub-populations) or custom models, in order to assist in the accurate classification of different cell types and subtypes.

The goal of this package is to provide a reference implementation of trait types for common data structures used in the scipy stack such as numpy arrays or pandas and xarray data structures. These are out of the scope of the main traitlets project but are a common requirement to build applications with traitlets in combination with the scipy stack.

cssselect2 is a straightforward implementation of CSS3 Selectors for markup documents (HTML, XML, etc.) that can be read by ElementTree-like parsers (including cElementTree, lxml, html5lib, etc.).

Unlike the Python package cssselect, it does not translate selectors to XPath and therefore does not have all the correctness corner cases that are hard or impossible to fix in cssselect.

Sign JSON objects with ED25519 signatures.

• More than one entity can sign the same object.

• Each entity can sign the object with more than one key making it easier to rotate keys

• ED25519 can be replaced with a different algorithm.

• Unprotected data can be added to the object under the "unsigned" key.

The zope.event package provides a simple event system, including:

- An event publishing API, intended for use by applications which are unaware of any subscribers to their events.

- A very simple synchronous event-dispatching system, on which more sophisticated event dispatching systems can be built. For example, a type-based event dispatching system that builds on zope.event can be found in zope.component.

Radio Beam is a simple toolkit for reading beam information from FITS headers and manipulating beams. Some example applications include:

• Convolution and deconvolution

• Unit conversion (Jy to/from K)

• Handle sets of beams for spectral cubes with varying resolution between channels

• Find the smallest common beam from a set of beams

• Add the beam shape to a matplotlib plot

Often when we want to label multiple points on a graph the text will start heavily overlapping with both other labels and data points. This can be a major problem requiring manual solution. However this can be largely automated by smart placing of the labels (difficult) or iterative adjustment of their positions to minimize overlaps (relatively easy). This library implements the latter option to help with matplotlib graphs.

Schematics is a Python library to combine types into structures, validate them, and transform the shapes of your data based on simple descriptions.

The internals are similar to ORM type systems, but there is no database layer in Schematics. Instead, building a database layer is easily made when Schematics handles everything except for writing the query. Schematics can be used for tasks where having a database involved is unusual.

Optimized einsum can significantly reduce the overall execution time of einsum-like expressions by optimizing the expression's contraction order and dispatching many operations to canonical BLAS, cuBLAS, or other specialized routines. Optimized einsum is agnostic to the backend and can handle NumPy, Dask, PyTorch, Tensorflow, CuPy, Sparse, Theano, JAX, and Autograd arrays as well as potentially any library which conforms to a standard API. See the documentation for more information.

This package provides a high-level, convenient API for managing internationalization/translation contexts in Python applications. There is a simple API for single-context applications, such as command line scripts which only need to translate into one language during the entire course of their execution. There is a more flexible, but still convenient API for multi-context applications, such as servers, which may need to switch language contexts for different tasks.

This is a small Python library that implements boolean algebra. It defines two base elements, TRUE and FALSE, and a Symbol class that can take on one of these two values. Calculations are done only in terms of AND, OR, and NOT---other compositions like XOR and NAND are emulated on top of them. Expressions are constructed from parsed strings or directly in Python.

The EDS-Pseudo project aims at detecting identifying entities in clinical documents, and was primarily tested on clinical reports at AP-HP's clinical data warehouse. The model is built on top of edsnlp, and consists in a hybrid model (rule-based + deep learning) for which we provide rules (eds-pseudo/pipes) and a training recipe. We also provide some fictitious templates and a script to generate a synthetic dataset.

Graph-tool is an efficient Python module for manipulation and statistical analysis of graphs (a.k.a. networks). Contrary to most other Python modules with similar functionality, the core data structures and algorithms are implemented in C++, making extensive use of template metaprogramming, based heavily on the Boost Graph Library. This confers it a level of performance that is comparable (both in memory usage and computation time) to that of a pure C/C++ library.

This package provides loaders and dumpers for PyYAML. Currently, an OrderedDict loader/dumper is implemented, allowing to keep items order when loading resp. dumping a file from/to an OrderedDict (Python 3.8+: Also regular dicts are supported and are the default items to be loaded to. As of Python 3.7 preservation of insertion order is a language feature of regular dicts.) It was originally mirrored from yamlordereddict.

Primer3-py is a Python-abstracted API for the popular Primer3 library. The intention is to provide a simple and reliable interface for automated oligo analysis and design.

Primer3-py also includes bindings for the Primer3 primer design engine if you’d prefer to use an established pipeline. The IO parameters mirror those of the original Primer3, but you don’t have to deal with messy and slow file IO for your automated workflows.

This module provides a nearly complete wrapping of the Oracle/Sleepycat C API for the Database Environment, Database, Cursor, Log Cursor, Sequence and Transaction objects, and each of these is exposed as a Python type in the bsddb3.db module. The database objects can use various access methods: btree, hash, recno, and queue. Complete support of Berkeley DB distributed transactions. Complete support for Berkeley DB Replication Manager. Complete support for Berkeley DB Base Replication. Support for RPC.

BlackSheep is a lightweight, asynchronous, event driven Web framework.

The framework offers

• A rich code API, based on dependency injection and inspired by Flask and ASP.NET Core.

• A typing-friendly codebase, which enables a comfortable development experience thanks to hints when coding with IDEs.

• Built-in generation of OpenAPI Documentation, supporting version 3, YAML, and JSON.

• A cross-platform framework, using the most modern versions of Python.

• Good performance.

JSON (JavaScript Object Notation) is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format.

Simplejson exposes an API familiar to users of the standard library marshal and pickle modules. It is the externally maintained version of the json library contained in Python 2.6, but maintains compatibility with Python 2.5 and (currently) has significant performance advantages, even without using the optional C extension for speedups. Simplejson is also supported on Python 3.3+.

The mercantile module provides ul(xtile, ytile, zoom) and bounds(xtile, ytile, zoom) functions that respectively return the upper left corner and bounding longitudes and latitudes for XYZ tiles, a xy(lng, lat) function that returns spherical mercator x and y coordinates, a tile(lng, lat, zoom) function that returns the tile containing a given point, and quadkey conversion functions quadkey(xtile, ytile, zoom) and quadkey_to_tile(quadkey) for translating between quadkey and tile coordinates.

This package is an integrated pipeline for large-scale phylogenetic profiling of genomes and metagenomes. PhyloPhlAn is an accurate, rapid, and easy-to-use method for large-scale microbial genome characterization and phylogenetic analysis at multiple levels of resolution. This software package can assign both genomes and MAGs to SGBs. PhyloPhlAn can reconstruct strain-level phylogenies using clade- specific maximally informative phylogenetic markers, and can also scale to very large phylogenies comprising >17,000 microbial species.

This package contains a plugin that provides specializations for type hinting stub files, especially interesting for linting typeshed. It adds the .pyi extension to the default value of the --filename command-line argument to Flake8. This means stubs are linted by default with this plugin enabled, without needing to explicitly list every file. It modifies PyFlakes runs for .pyi files to defer checking type annotation expressions after the entire file has been read. This enables support for first-class forward references that stub files use.

pandapower is an easy to use network calculation program aimed to automate the analysis and optimization of power systems. It uses the data analysis library pandas and is compatible with the commonly used MATPOWER / PYPOWER case format. pandapower allows using different solvers including an improved Newton-Raphson power flow implementation, all PYPOWER solvers, the C++ library solvers for fast steady-state distribution power system analysis of PowerGridModel, the Newton-Raphson power flow solvers in the C++ library lightsim2grid, and the PowerModels.jl library.

The FEniCS Form Compiler (FFC) is a compiler for finite element variational forms. From a high-level description of the form, it generates efficient low-level C++ code that can be used to assemble the corresponding discrete operator (tensor). In particular, a bilinear form may be assembled into a matrix and a linear form may be assembled into a vector. FFC may be used either from the command line (by invoking the ffc command) or as a Python module (import ffc).

FFC is part of the FEniCS Project.

Hydra is an open-source Python framework that simplifies the development of research and other complex applications. The key feature is the ability to dynamically create a hierarchical configuration by composition and override it through config files and the command line.

Key features:

• Hierarchical configuration composable from multiple sources

• Configuration can be specified or overridden from the command line

• Dynamic command line tab completion

• Run your application locally or launch it to run remotely

• Run multiple jobs with different arguments with a single command