📚 Joey Documentation Library

API references and cheat-sheets for 234 Python packages

1. 🤖 Artificial Intelligence & Machine Learning

📦 anthropic
The official Python client SDK for interacting with Anthropic's Claude family of Large Language Models (LLMs). It provides native methods for prompt completion, streaming responses, and managing API keys, facilitating the integration of advanced AI conversational and reasoning capabilities into applications.
📦 catboost
A high-performance open-source gradient boosting library on decision trees. It is specifically optimized to handle categorical features automatically without extensive preprocessing, providing superior accuracy and robustness against overfitting in machine learning classification and regression tasks.
📦 datasets
A Hugging Face library designed to simplify the process of loading, processing, and sharing machine learning datasets. It provides a unified API to access thousands of public datasets, efficiently handles memory management via memory mapping, and integrates seamlessly with popular ML frameworks like PyTorch and TensorFlow.
📦 faiss
An open-source library developed by Meta AI, optimized for the efficient similarity search and clustering of dense vectors. It enables searching through massive multimedia databases in milliseconds, forming the backbone for many modern AI applications like recommendation systems and LLM retrieval-augmented generation (RAG).
📦 huggingface-hub
The official Python client library for the Hugging Face Hub. It enables developers to programmatically download and upload machine learning models, datasets, and demos, streamlining the integration of open-source AI resources into local workflows and collaborative projects.
📦 langchain
A powerful open-source framework designed for building applications powered by Large Language Models (LLMs). It provides abstractions for prompt management, chains of operations, memory, and agent-based decision making, enabling complex context-aware AI applications like chatbots and RAG systems.
📦 lightgbm
A highly efficient, distributed gradient boosting framework developed by Microsoft that uses tree-based learning algorithms. It is designed for speed and memory efficiency, capable of handling massive datasets and outperforming other boosting libraries by growing trees leaf-wise rather than level-wise.
📦 llama-index
A data framework designed to connect custom data sources (like PDFs, databases, or APIs) to Large Language Models. It provides tools for data ingestion, structuring, and retrieval, enabling the creation of accurate, context-augmented AI applications that can safely reason over an organization's private data.
📦 mlflow
An open-source platform designed to manage the end-to-end machine learning lifecycle. It provides tools for tracking experiments (logging metrics and parameters), packaging code into reproducible runs, and managing model deployment across various serving environments.
📦 openai
The official Python client library for accessing the OpenAI REST API. It allows developers to easily integrate powerful AI models like GPT-4, DALL-E, and Whisper into their Python applications, handling authentication, prompt formatting, and streaming responses.
📦 optuna
An open-source automatic hyperparameter optimization software framework designed specifically for machine learning. It employs advanced algorithms like Tree-structured Parzen Estimators (TPE) to efficiently explore hyperparameter search spaces, enabling developers to find optimal model configurations faster.
📦 scikit-learn
A fundamental, open-source machine learning library for Python. It provides simple and efficient tools for predictive data analysis, including classification, regression, clustering, and dimensionality reduction, featuring a consistent API that makes it the starting point for most ML workflows.
📦 shap
A unified approach to explain the output of any machine learning model. It uses game theory (Shapley Additive exPlanations) to assign importance values to each feature, providing deep insights into how models make specific predictions, crucial for AI transparency and fairness.
📦 tiktoken
A highly optimized open-source tokenizer developed by OpenAI. It implements Byte Pair Encoding (BPE) to rapidly convert text strings into the exact integer token sequences expected by models like GPT-3.5 and GPT-4, crucial for accurate prompt length calculation.
📦 torch
The PyTorch deep learning framework, developed by Meta. It provides highly optimized tensor computation with strong GPU acceleration and a dynamic computational graph system, making it the preferred library for researchers and engineers building complex neural networks and AI models.
📦 xgboost
An optimized distributed gradient boosting library designed to be highly efficient, flexible, and portable. It implements machine learning algorithms under the Gradient Boosting framework, providing parallel tree boosting that solves many data science problems accurately and rapidly.

2. 📐 CAD, 3D Modeling & Digital Fabrication

📦 build123d
A modern Python CAD library built on the Open Cascade geometric kernel that allows users to create precise 2D and 3D parametric models using code. Designed for 3D printing, CNC machining, and laser cutting, it offers a clean, Pythonic interface for CAD-as-code workflows.
📦 cadquery
A highly flexible parametric 3D CAD modeling framework written in Python. It allows engineers and designers to script complex 3D solid models using standard Python code, prioritizing functional design logic and making it perfect for automating mechanical engineering tasks and generating manufacturing-ready models.
📦 ezdxf
A powerful Python interface for creating and modifying DXF (Drawing Exchange Format) drawings, completely independent of AutoCAD. It allows developers to read, write, and manipulate CAD structures like lines, text, and blocks, making it an excellent tool for automating architectural and engineering drafting workflows.
📦 numpy-stl
A highly specialized Python library built on top of NumPy designed for reading, writing, and manipulating 3D STL (Stereolithography) files. It leverages NumPy arrays to efficiently process 3D mesh geometry, making it ideal for 3D printing applications and basic CAD file processing.
📦 open3d
An open-source modern library that supports rapid development of software dealing with 3D data. It handles core 3D operations like point cloud processing, mesh reconstruction, and scene rendering, providing robust C++ backend optimizations exposed through a Python interface.
📦 pyclipper
pyclipper is a Python wrapper around the Clipper library, designed for polygon clipping and offsetting operations. It allows you to perform unions, intersections, differences, and offsets on complex polygonal shapes. This makes it especially useful in nesting workflows, where you need to detect overlaps, create toolpath offsets, or expand and shrink shapes for CNC cutting.
📦 pygcode
pygcode is a library for parsing and interpreting G‑code, the standard language used to control CNC machines and 3D printers. It allows developers to read, analyze, and manipulate G‑code commands programmatically, making it useful for building custom slicers, simulators, or machine control software.
📦 pymeshlab
A Python binding for the MeshLab processing engine. It allows developers to automate the batch processing of 3D triangular meshes, applying complex geometric filters (like simplification, smoothing, and remeshing) directly in Python scripts for digital fabrication and geometry analysis.
📦 pyvista
A high-level 3D plotting and mesh analysis library built on top of the Visualization Toolkit (VTK). It provides a streamlined, NumPy-friendly Python interface for spatial filtering, 3D rendering, and complex mesh analysis, making scientific 3D visualization highly accessible.
📦 rectpack
rectpack is a specialized library for rectangle packing and nesting. It provides algorithms to efficiently place rectangles into bins or sheets, minimizing wasted space. While limited to rectangular shapes, it’s very effective for layout problems in sheet cutting or packaging.
📦 shapely
Shapely is a Python library for manipulating and analyzing planar geometric objects. It provides a simple and intuitive interface for creating, transforming, and querying geometric shapes, making it ideal for spatial analysis and GIS applications.
📦 steputils
A specialized Python package designed for handling ISO 10303 STEP files, the universal standard for 3D product data exchange. It allows developers to programmatically parse, inspect, and modify complex CAD geometry and assembly hierarchies directly in Python.
📦 trimesh
A pure-Python library designed for loading, inspecting, and analyzing 3D triangular meshes. It provides robust tools to calculate surface area, volume, split meshes, and export 3D models, widely used in computer graphics, 3D printing, and robotic path planning.
📦 vtracer
vtracer is a Python library designed for raster‑to‑vector conversion, similar in spirit to Potrace but implemented with modern tooling. Its main purpose is to take bitmap images (such as PNG or JPEG) and convert them into scalable vector graphics (SVG) paths. It works by tracing the outlines of shapes in the raster image and producing smooth Bézier curves that represent those contours. This makes it especially useful when you want to transform logos, scanned sketches, or pixel‑based artwork into clean vector files that can be scaled without loss of quality. In workflows related to CNC cutting, laser engraving, or digital fabrication, vtracer allows you to take hand‑drawn or raster input and generate precise SVG paths that can then be nested, manipulated, or exported for production. It’s lightweight, easy to integrate into Python projects, and provides a straightforward way to bridge the gap between raster graphics and vector‑based design.

3. 💻 CLI, Terminal & Progress Tools

📦 about_time
about_time is a utility library for measuring execution time and benchmarking code. It provides decorators and context managers to track performance in a human‑friendly way, making it useful for profiling and optimizing Python applications.
📦 alive_progress
alive_progress is a modern progress bar library that provides visually appealing, animated progress indicators for loops and tasks. It enhances user experience in command‑line applications by showing real‑time progress, estimated completion, and customizable styles.
📦 argparse
The standard Python module for building user-friendly command-line interfaces. It automatically generates help menus, handles error messaging, and parses complex command-line arguments, flags, and sub-commands, enabling developers to easily configure script behaviors from the terminal.
📦 click
A popular Python package for creating beautiful and composable command-line interfaces (CLIs) in a highly readable way. It uses decorators to define commands, arguments, and options, automatically handling help text generation, context passing, and complex nested command structures.
📦 colorama
A cross-platform Python library that makes terminal text coloring and cursor positioning simple. It internally translates ANSI escape codes into standard Windows API calls, ensuring that colored command-line output works seamlessly across Windows, Linux, and macOS without complex configurations.
📦 loguru
A modern Python logging library designed to make logging simple and painless. It comes pre-configured with sensible defaults, colored console output, safe serialization, and a highly readable API, completely eliminating the boilerplate setup required by the standard `logging` module.
📦 rich
A Python library for rich text and beautiful formatting in the terminal. It allows developers to render markdown, syntax-highlighted code, interactive tables, and progress bars directly in the console, drastically improving the readability of command-line application output.
📦 tqdm
A fast, extensible Python library designed to display smart progress bars for loops and long-running computations. It seamlessly wraps iterables, providing real-time iteration speed, estimated time of arrival, and visual feedback in the console or Jupyter Notebooks.
📦 typer
A modern Python library for building command-line interface (CLI) applications, built on top of Click. It leverages standard Python type hints to automatically generate argument parsing, help menus, and validation, making CLI development highly intuitive and developer-friendly.

4. 📊 Data Science, Analytics & Visualization

📦 autograd
autograd is a library for automatic differentiation of Python and NumPy code. It tracks operations on arrays and computes gradients automatically, which is crucial for optimization, machine learning, and deep learning tasks where gradient‑based methods are used.
📦 bokeh
An interactive data visualization library for modern web browsers. It provides elegant, concise construction of versatile graphics, from simple plots to complex dashboards, and outputs highly interactive visualizations in HTML and JavaScript without requiring explicit web development.
📦 matplotlib
A comprehensive and foundational data visualization library for Python. It provides an object-oriented API for embedding static, interactive, and animated plots into applications, capable of generating highly customizable, publication-quality figures in a wide variety of hardcopy formats.
📦 networkx
A Python library for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks. It provides tools to model nodes and edges, allowing for deep graph algorithm analysis (shortest path, centrality) on social networks, logistics, and biological structures.
📦 numpy
The fundamental package for scientific computing in Python. It provides a high-performance multidimensional array object (`ndarray`), along with tools for working with these arrays, serving as the core mathematical engine upon which almost all major Python data science libraries are built.
📦 pandas
A fast, powerful, and flexible open-source data analysis and manipulation tool built on top of Python. It introduces the `DataFrame` structure, allowing for intuitive handling of tabular data, time-series operations, and complex database-like queries, making it the standard for data science workflows.
📦 plotly
An open-source, interactive graphing library for Python. It allows users to create highly interactive, publication-quality web-based plots (like scatter plots, heatmaps, and 3D meshes) that can be displayed in browsers or embedded in dashboards without requiring JavaScript.
📦 polars
A blazingly fast, multi-threaded DataFrame library written in Rust. It utilizes the Apache Arrow memory format to process large datasets efficiently, providing a Python API that significantly outperforms Pandas in speed and memory usage, especially for out-of-core operations.
📦 pyarrow
The Python binding for Apache Arrow, a cross-language development platform for in-memory data. It provides highly efficient columnar memory structures and tools for reading/writing formats like Parquet, dramatically speeding up data interchange between Python and other data processing engines.
📦 seaborn
A Python data visualization library based on Matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics, simplifying the creation of complex visualizations like heatmaps, violin plots, and regression plots with beautiful default styling.

5. 🗄️ Databases, ORM & Storage

📦 alembic
A lightweight and highly configurable database migration tool designed specifically for SQLAlchemy. It allows developers to manage and version-control database schema changes through auto-generated migration scripts, ensuring smooth transitions between database states without data loss.
📦 asyncpg
A blazingly fast, high-performance asynchronous PostgreSQL database client library engineered specifically for Python's asyncio. It directly implements the PostgreSQL protocol without relying on C extensions, providing non-blocking database queries, connection pooling, and type conversion for scalable I/O applications.
📦 azure-storage-blob
The official Microsoft Azure Blob Storage client library for Python, facilitating seamless management of cloud-based unstructured data. It allows developers to securely upload, download, list, and manage blobs (objects) and containers, integrating deeply with Azure's scalable storage infrastructure.
📦 duckdb
A high-performance in-process analytical SQL database engine designed for fast OLAP (Online Analytical Processing) queries. It runs locally within the Python process, providing lightning-fast execution of complex aggregations and joins on massive datasets without the need for a separate database server.
📦 elasticsearch
The official Python client for Elasticsearch, a powerful distributed RESTful search and analytics engine. It provides a Pythonic interface for indexing documents, executing complex full-text queries, and managing clusters, widely used for building search bars, log analytics, and monitoring dashboards.
📦 erppeek

Erppeek — A Python client for Odoo that provides a simple, script‑friendly interface to the Odoo XML‑RPC and JSON‑RPC APIs. It enables developers to connect to Odoo databases, perform CRUD operations, and automate workflows without needing the full Odoo environment.

Key Features

  • Lightweight Python client for Odoo’s XML‑RPC and JSON‑RPC APIs.
  • Supports search, read, write, and create operations.
  • Interactive shell for quick exploration and debugging.
  • Ideal for scripting, automation, and integration tasks.
  • Works with multiple Odoo versions.

Use Cases

  • Automating repetitive Odoo tasks via Python scripts.
  • Integrating Odoo with external systems and services.
  • Rapid prototyping of Odoo extensions and workflows.
  • Exploring and manipulating Odoo data without full server setup.
📦 google-cloud-storage
The official Google Cloud Storage client library for Python. It provides a programmatic interface to store, retrieve, and manage large unstructured data files (objects) in Google Cloud buckets, supporting features like resumable uploads, signed URLs, and access control lists (ACLs).
📦 odoorpc

OdooRPC (XML-RPC Client) — A Python client for interacting with Odoo's XML-RPC API. It provides a simple and intuitive interface for performing common operations like reading, writing, and searching records in an Odoo database.

Key Features

  • Connects seamlessly to Odoo via XML-RPC.
  • Supports common operations: read, write, search.
  • Pythonic interface for database interaction.
  • Ideal for automation, integration, and custom tooling.

Use Cases

  • Automating repetitive tasks in Odoo.
  • Building integrations with external systems.
  • Prototyping custom Odoo extensions.
📦 odoorpc-toolbox

OdooRPC Toolbox — A collection of utilities and extensions for the odoorpc library, enhancing its functionality and providing additional features for working with Odoo's XML-RPC API.

Key Enhancements

  • Extended helpers for read, write, and search operations.
  • Improved error handling and logging.
  • Convenience wrappers for common Odoo models.
  • Additional abstractions for smoother integration.

Use Cases

  • Building automation scripts for Odoo workflows.
  • Integrating Odoo with external systems.
  • Rapid prototyping of Odoo extensions.
📦 peewee
A simple, lightweight, and expressive Object-Relational Mapper (ORM) for Python. It provides a clean Pythonic API for defining database models and executing queries, supporting SQLite, MySQL, and PostgreSQL without the heavy boilerplate and complexity of larger ORMs like SQLAlchemy.
📦 psycopg
psycopg is the official PostgreSQL adapter for Python, providing a fast, reliable, and feature‑rich interface to connect applications with PostgreSQL databases. Built on top of PostgreSQL’s native libpq library, it fully implements the Python DB‑API 2.0 standard and supports both synchronous and asynchronous programming models in its modern version (psycopg3). Psycopg offers efficient query execution, strong protection against SQL injection through parameterized queries, and advanced PostgreSQL features such as LISTEN/NOTIFY, COPY for bulk data transfer, and large object handling. Widely used in production environments, it integrates seamlessly with frameworks like Django and ORMs such as SQLAlchemy, making it the de facto standard connector for Python developers working with PostgreSQL.
📦 psycopg2
The most popular PostgreSQL adapter for Python. It implements the standard Python DB-API 2.0 interface, allowing Python applications to execute SQL commands, manage transactions, and interact with PostgreSQL databases efficiently, supporting both synchronous and thread-safe operations.
📦 pymongo
The official Python driver for MongoDB. It provides a rich, Pythonic interface for connecting to MongoDB databases, inserting JSON-like documents, building complex aggregation pipelines, and managing indexes in NoSQL database workflows.
📦 redis
The standard Python client for Redis, an advanced in-memory key-value store. It allows Python applications to interact with Redis for high-speed data caching, session storage, message brokering via Pub/Sub, and real-time analytics.
📦 shelve
A standard Python module that acts like a persistent dictionary. It 'pickles' Python objects and stores them in a database file on disk, allowing data to survive between script executions without needing to set up a full database management system.
📦 sqlalchemy
The Python SQL toolkit and Object Relational Mapper (ORM) that gives application developers the full power and flexibility of SQL. It provides a comprehensive suite of enterprise-level persistence patterns, allowing developers to interact with SQL databases using Python objects.
📦 sqlite3
A standard Python module providing a lightweight, disk-based database that doesn't require a separate server process. It allows Python applications to create, read, and update SQLite databases seamlessly, making it ideal for local data storage, testing, and small application backends.
📦 sqlmodel
A powerful Python library designed to bridge the gap between Pydantic and SQLAlchemy. It allows developers to define database models using standard Python type hints, automatically generating SQL schemas while providing Pydantic's robust validation and serialization features.

6. ☁️ DevOps, Cloud & System Administration

📦 ansible
A radically simple IT automation engine that automates cloud provisioning, configuration management, application deployment, intra-service orchestration, and many other IT needs. It uses declarative YAML playbooks to describe infrastructure as code, operating agentlessly over SSH.
📦 boto3
The official Amazon Web Services (AWS) Software Development Kit (SDK) for Python. It allows developers to write Python scripts and applications that create, configure, and manage AWS services and resources, such as EC2 instances, S3 buckets, and DynamoDB tables, via API calls.
📦 docker
The official Python SDK for the Docker Engine API. It allows developers to programmatically automate the building, shipping, and running of applications inside Docker containers, enabling dynamic management of container lifecycles, networks, and image registries directly from Python scripts.
📦 kubernetes
The official Python client library for the Kubernetes API. It allows developers to programmatically deploy, scale, and manage containerized applications within Kubernetes clusters, handling authentication, API resource manipulation, and cluster monitoring directly from Python code.
📦 paramiko
A pure-Python implementation of the SSHv2 protocol, providing both client and server functionality. It allows Python scripts to securely connect to remote machines, execute commands over an encrypted channel, and transfer files via SFTP without relying on external SSH binaries.
📦 psutil
A cross-platform Python library for retrieving information on running processes and system utilization (CPU, memory, disks, network, sensors). It provides a unified interface across Linux, Windows, and macOS, making it essential for building system monitoring tools and task managers.

7. 🎨 GUI, Graphics & Document Processing

📦 arabic_reshaper
A specialized Python library that reconstructs Arabic text characters into their proper presentation forms. It connects isolated Arabic letters into their correct cursive glyph shapes, making Arabic text render correctly in environments that lack native bidirectional (BiDi) text support, such as PDF generators or certain plotting libraries.
📦 cairosvg
cairosvg is a conversion library that transforms SVG files into other formats such as PNG, PDF, or PostScript. Built on the Cairo graphics engine, it’s useful when you need to export nested layouts into raster images or printable documents for reports, presentations, or production.
📦 docx
A popular Python library for creating, reading, and updating Microsoft Word (.docx) files. It allows developers to programmatically manipulate document elements like paragraphs, tables, styles, and images, completely bypassing the need for the Microsoft Word application itself.
📦 drawsvg
drawsvg is a Python library for generating and visualizing SVG graphics programmatically. It provides an intuitive API for creating shapes, paths, text, and even animations, and can render outputs to PNG or MP4. It’s particularly handy for visualizing nested layouts or producing documentation graphics directly from code.
📦 html5lib
A pure-Python library for parsing HTML documents. It strictly follows the WHATWG HTML specification (the same one web browsers use), making it extremely robust at parsing broken or malformed HTML markup into a reliable tree structure for web scraping.
📦 lxml
A highly performant and feature-rich Python library for processing XML and HTML. It provides Pythonic bindings for the libxml2 and libxslt C libraries, enabling extremely fast parsing, XPath querying, and XSLT transformations of complex document structures.
📦 opencv-python
The official Python wrapper for OpenCV (Open Source Computer Vision Library). It provides a massive collection of highly optimized computer vision algorithms, enabling real-time image processing, object detection, face recognition, and video analysis.
📦 openpyxl
A pure-Python library designed to read, write, and modify Excel 2010+ files (`.xlsx`, `.xlsm`). It allows developers to programmatically create complex spreadsheets, manipulate cells, apply formulas, and format charts without needing the Microsoft Excel software installed.
📦 pdfplumber
A Python library built on `pdfminer.six` designed for precise extraction of text, tables, and layout coordinates from PDFs. It allows developers to plumb the depths of PDF structures, accurately parsing complex table grids and character positions that standard text extractors miss.
📦 pillow
The friendly fork of the Python Imaging Library (PIL). It adds support for opening, manipulating, and saving a wide variety of image file formats, providing essential capabilities for image resizing, cropping, filtering, and pixel manipulation in Python.
📦 pycairo
pycairo is a set of Python bindings for the Cairo graphics library, enabling vector drawing, text rendering, and image creation. It serves as a backend for rendering SVGs, PDFs, or custom visualizations, making it useful for producing high-quality graphics in engineering workflows.
📦 pypdf
A pure-Python library built for reading, writing, and manipulating PDF files. It can split, merge, crop, and transform PDF pages, as well as extract metadata and text, providing a completely self-contained toolkit for basic PDF document management.
📦 python-bidi
A pure-Python implementation of the Unicode Bidirectional Algorithm. It is essential for correctly displaying text that mixes Left-to-Right (LTR) and Right-to-Left (RTL) scripts (like Arabic or Hebrew), ensuring characters are laid out in the correct visual order.
📦 scikit-image
An open-source image processing library for Python. Built on NumPy, it provides a collection of algorithms for image segmentation, geometric transformations, color space manipulation, and feature detection, essential for scientific image analysis and computer vision research.
📦 svglib
svglib is a library that reads SVG files and converts them into ReportLab drawing objects. This allows you to integrate SVG graphics into PDF workflows seamlessly. It’s particularly useful when you want to include vector diagrams or nested layouts in professional reports.
📦 svgpathtools
svgpathtools focuses on parsing and manipulating SVG path data. It lets you compute path lengths, intersections, and transformations, and provides utilities for analyzing complex path strings. This makes it ideal for toolpath analysis, geometric alignment, and precision operations in CNC or laser cutting contexts.
📦 svgwrite
svgwrite is a lightweight library for creating SVG files. It offers a simple API to draw shapes, text, gradients, and other vector elements. Because of its simplicity, it’s often used when you need to generate clean SVGs for CNC or laser cutting workflows without heavy dependencies.
📦 tkinter
The standard Python interface to the Tcl/Tk GUI toolkit. It is included with Python by default and allows developers to quickly build simple desktop graphical user interfaces (GUIs) with buttons, text fields, and windows without installing external dependencies.
📦 weasyprint

Weasyprint (HTML/CSS to PDF Converter) — A fast and lightweight Python library for converting HTML and CSS documents into PDFs. It provides a simple API for generating high‑quality printable documents from web content, making it ideal for creating reports, invoices, and other professionally formatted outputs.

Key Features

  • Converts HTML and CSS into PDF with precision.
  • Lightweight and optimized for performance.
  • Simple, Pythonic API for easy integration.
  • Generates professional, print‑ready documents.

Use Cases

  • Automated report generation.
  • Invoice creation from web templates.
  • Exporting styled web content into PDF format.
  • Building document workflows in Python applications.

8. 🌐 HTTP, Networking & Web Scraping

📦 aiohttp
A powerful asynchronous HTTP client and server framework built on Python's asyncio. It provides a robust API for handling concurrent network requests, WebSockets, and middleware, making it ideal for high-performance, non-blocking web applications and microservices.
📦 beautifulsoup4
A powerful Python library for pulling data out of HTML and XML files. It creates parse trees from page source code that can be used to extract data, navigating the DOM using simple Pythonic idioms for searching and modifying tags, making web scraping highly accessible.
📦 httpx
A next-generation, fully-featured HTTP client for Python. It offers both synchronous and asynchronous APIs, supports HTTP/1.1 and HTTP/2, and includes features like connection pooling, timeouts, and advanced authentication, serving as a modern alternative to the `requests` library.
📦 pika
A pure-Python implementation of the AMQP 0-9-1 protocol, primarily used to connect Python applications to RabbitMQ message brokers. It provides robust tools for publishing and consuming asynchronous messages, enabling reliable decoupling of microservices.
📦 playwright
A modern Python library for browser automation developed by Microsoft. It provides a single API to control Chromium, Firefox, and WebKit, enabling reliable end-to-end testing, web scraping, and automated interactions with complex, dynamically rendered single-page applications.
📦 python-telegram-bot

Python Telegram Bot (Async Telegram Bot Framework) — A pure‑Python asynchronous framework that wraps the Telegram Bot API. It provides an object‑oriented, high‑level interface for building custom Telegram bots, handling commands, sending media, and managing interactive conversations seamlessly.

Key Features

  • Asynchronous design for scalable performance.
  • Object‑oriented interface for clean bot architecture.
  • Built‑in support for commands, callbacks, and events.
  • Easy handling of media (images, audio, documents).
  • Interactive conversation management with minimal boilerplate.

Use Cases

  • Building custom Telegram bots for communities or businesses.
  • Automating workflows and notifications via Telegram.
  • Creating interactive chat experiences with menus and forms.
  • Integrating Telegram bots into larger Python applications.
📦 requests

Requests — A widely popular, elegant, and simple HTTP library for Python. It abstracts the complexities of HTTP requests behind a beautiful, simple API, making it incredibly easy to send GET/POST requests, handle cookies, and manage authentication when interacting with web services.

The Requests library in Python is one of the most widely used and elegant tools for handling HTTP communication. It abstracts away the complexities of low-level networking code, offering developers a clean and intuitive API for sending GET, POST, PUT, DELETE, and other HTTP methods. With Requests, you can easily manage cookies, headers, sessions, and authentication without needing to manually handle sockets or protocol details.

🌐 REST API Integration

One of the most powerful aspects of Requests is how seamlessly it works with RESTful APIs. Since REST APIs rely heavily on HTTP methods to perform operations on resources, Requests provides a natural way to interact with them. For example:

  • GET → Retrieve data from an endpoint (e.g., fetching user details).
  • POST → Send new data to the server (e.g., creating a new record).
  • PUT/PATCH → Update existing resources.
  • DELETE → Remove resources.

By combining Requests with JSON handling in Python, developers can quickly consume and manipulate REST API responses. This makes it ideal for tasks like:

  • Integrating with web services (e.g., GitHub API, Twitter API).
  • Automating workflows that depend on external APIs.
  • Building prototypes for client-server applications.

✨ In short, Requests turns the often tedious process of working with HTTP and REST APIs into something simple, elegant, and Pythonic — letting you focus on the logic of your application rather than the intricacies of the protocol.

📦 scrapy
A fast, high-level web crawling and web scraping framework for Python. It handles request scheduling, concurrent downloading, and data extraction via selectors, allowing developers to build scalable spiders that efficiently scrape and structure data from thousands of web pages.
📦 select
A standard Python module providing access to the `select` and `poll` system calls. It allows developers to monitor multiple I/O streams (like sockets) simultaneously, waiting until data is ready to be read or written, which is essential for building efficient asynchronous network servers.
📦 selenium
A powerful suite of tools for automating web browsers. It allows Python scripts to programmatically control a browser, simulating clicks, typing, and navigation, which is heavily used for end-to-end testing of web applications and scraping dynamic, JavaScript-heavy websites.
📦 smtplib
A standard Python module defining an SMTP client session object. It allows Python applications to connect to mail servers (like Gmail or Outlook) and send Simple Mail Transfer Protocol (SMTP) messages, enabling automated email notifications and alerts.
📦 socket
A standard Python module exposing the BSD socket interface. It provides low-level access to network communication, allowing developers to build custom TCP/IP clients and servers, manage raw network packets, and implement custom network protocols.
📦 socketio
A Python implementation of the Socket.IO protocol, enabling real-time, bidirectional, and event-based communication between web clients and servers. It supports seamless fallbacks and websockets, making it perfect for building chat apps, multiplayer games, and live dashboards.
📦 telegram

Telegram (Bot API Wrapper) — A pure‑Python interface that provides a lightweight wrapper around the official Telegram Bot API. It allows developers to programmatically send messages, images, and documents, as well as set up webhook listeners for building automated Telegram bots.

Key Features

  • Lightweight Python wrapper for the official Telegram Bot API.
  • Programmatic support for sending messages, images, and documents.
  • Webhook listener setup for real‑time bot interactions.
  • Simple, object‑oriented interface for clean bot development.

Use Cases

  • Building custom Telegram bots for communities or businesses.
  • Automating notifications and alerts via Telegram.
  • Integrating Telegram bots into larger Python applications.
  • Creating interactive chat experiences with media support.
📦 urllib
A standard Python package collecting several modules for working with URLs. It provides tools to parse URL structures, encode query parameters, and perform basic HTTP requests and handle responses, serving as the underlying engine for many higher-level web libraries.
📦 webbrowser
A standard Python module that provides a high-level interface allowing Python scripts to open URLs in the user's default web browser. It supports opening standard links, new tabs, or specific browser instances, ideal for OAuth flows and simple help pages.
📦 websockets
A robust Python library for building WebSocket servers and clients. Built entirely on Python's `asyncio`, it focuses on simplicity, correctness, and performance, enabling real-time, bidirectional communication between client browsers and backend servers.

9. 🔬 Mathematics, Physics & Engineering Simulation

📦 cantera
An open-source suite of tools for problems involving chemical kinetics, thermodynamics, and transport processes. It allows engineers and scientists to simulate complex chemical reactions, combustion processes, and fluid dynamics with high precision, bypassing the need for proprietary software.
📦 cma
cma is a Python implementation of the Covariance Matrix Adaptation Evolution Strategy (CMA‑ES), a powerful stochastic optimization algorithm. It is widely used for solving non‑linear, non‑convex optimization problems in engineering, machine learning, and scientific research.
📦 control
The Python Control Systems Library, designed to implement basic operations for analyzing and designing feedback control systems. It provides tools for state-space modeling, frequency domain analysis, Bode/Nyquist plots, and PID controller tuning, bridging the gap between Python and control engineering.
📦 coolprop
A C++ library with Python bindings that provides high-accuracy thermophysical properties for pure fluids, pseudo-pure fluids, and humid air. It is widely used in HVAC, chemical engineering, and thermodynamics research to calculate density, viscosity, heat capacity, and phase equilibria based on reference equations of state.
📦 euclid
euclid is a geometry library that provides classes and functions for working with 2D and 3D vectors, points, and transformations. It simplifies geometric computations such as rotations, translations, and scaling, making it useful for graphics, simulations, and CAD applications.
📦 fluidfoam
A specialized Python package designed to interface with OpenFOAM (a popular CFD software). It allows engineers to easily read structured and unstructured mesh data, extract field variables (like velocity and pressure), and process Computational Fluid Dynamics simulation results directly in Python.
📦 moocore
moocore is a lightweight Python package that provides core utilities for optimization and modeling workflows. It is often used as a supporting library in larger optimization frameworks, offering foundational structures and helper functions for algorithm development.
📦 mpmath
mpmath is a Python library for arbitrary‑precision arithmetic, allowing computations with very high numerical accuracy. It supports advanced mathematical functions, calculus, linear algebra, and numerical analysis, making it essential for scientific computing where precision beyond standard floating‑point is required.
📦 numba
An open-source Just-In-Time (JIT) compiler for Python that translates a subset of Python and NumPy code into fast machine code. It allows mathematical and scientific code to achieve performance levels comparable to C or Fortran, without requiring users to change their Python syntax.
📦 pydy
pydy (short for Python Dynamics) is a library for modeling and simulating multibody dynamics. Built on SymPy and NumPy, it enables users to define mechanical systems symbolically and then generate numerical simulations, making it valuable for robotics, biomechanics, and mechanical engineering research.
📦 pymoo
pymoo is a Python framework for multi‑objective optimization that provides a wide range of evolutionary algorithms, genetic algorithms, and optimization techniques. It is designed for research and practical applications where problems involve conflicting objectives, offering tools for algorithm customization, visualization, and benchmarking.
📦 pyvib
A Python library focused on mechanical vibration analysis. It provides numerical tools to simulate dynamic system responses, perform modal analysis, and process time-series signals, widely used in mechanical engineering to study structural fatigue and resonance.
📦 pyvibe
A highly specialized data visualization library designed for structural dynamics and vibration engineering. It integrates with plotting backends to generate specific charts like frequency response functions (FRF) and time-domain vibration signals, aiding engineers in data interpretation.
📦 scipy
A fundamental open-source software library for scientific computing. Built on NumPy, it provides a vast collection of mathematical algorithms for optimization, integration, interpolation, eigenvalue problems, and signal processing, forming the backbone of Python-based scientific research.
📦 spatialmath-python
A Python library providing classes to represent spatial mathematics, including 3D rotations, rigid body transformations, and quaternions. It provides essential mathematical tools for robotics, computer vision, and mechanical engineering applications requiring precise spatial coordinate manipulation.
📦 statsmodels
A Python module that provides classes and functions for the estimation of many different statistical models. It allows users to perform statistical tests, explore data, and estimate models like GLM, OLS, and time-series analysis (ARIMA), making it essential for econometrics and statistics.
📦 sympy
A Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code simple and extensible. It can perform algebraic manipulations, calculus, equation solving, and matrix operations symbolically, returning exact mathematical expressions.

10. 🔒 Security, Cryptography & Authentication

📦 argon2-cffi
A secure, modern password hashing library that implements the Argon2 algorithm, the winner of the Password Hashing Competition (PHC). It provides robust protection against GPU-based brute-force attacks by utilizing configurable memory hardness, parallelism, and time costs to securely store user credentials.
📦 authlib
A comprehensive authentication and authorization library supporting OAuth 1.0, OAuth 2.0, OpenID Connect, and JOSE (JWT, JWS, JWE). It offers both client and server implementations, enabling secure API authentication, token generation, and session management across modern web frameworks.
📦 bcrypt
A robust password hashing library that implements the Blowfish-based bcrypt cipher. It incorporates a cryptographic salt to protect against rainbow table attacks and is deliberately slow to compute, making it highly resistant to brute-force password cracking attempts.
📦 cryptography
A robust Python library that exposes both high-level 'recipes' and low-level interfaces to common cryptographic algorithms. It provides secure implementations of symmetric/asymmetric encryption, message digests, key derivation functions, and digital signatures, adhering to modern security best practices.
📦 hashlib
A standard Python module that implements a common interface to many different secure hash and message digest algorithms. It allows developers to generate cryptographic hashes (like SHA-256 or MD5) for data integrity verification, password storage (with salting), and digital signatures.
📦 hmac
A standard Python module implementing the HMAC (Hash-based Message Authentication Code) algorithm. It uses a cryptographic hash function and a secret key to verify both the data integrity and the authenticity of a message, widely used in API authentication and secure webhooks.
📦 itsdangerous
A Python library developed by the Flask team that provides cryptographic signing tools. It securely serializes data (like session cookies) into a string that can be safely sent to untrusted clients, ensuring the data cannot be tampered with before being sent back to the server.
📦 passlib
A flexible, comprehensive password hashing library for Python. It provides a unified interface to over 30 hashing algorithms (like bcrypt, Argon2, and PBKDF2), handling automatic salt generation, hash migration, and deprecated algorithm identification for secure user authentication.
📦 pycryptodome
A self-contained Python package of low-level cryptographic primitives. It serves as a drop-in replacement for the old PyCrypto library, providing robust and modern implementations of symmetric/asymmetric ciphers, hash functions, and message authentication codes.
📦 pyjwt
A Python library used to encode and decode JSON Web Tokens (JWTs). It allows developers to securely generate tokens for API authentication, verify token signatures (using HMAC or RSA), and extract user claims without relying on external services.
📦 python-jose
A comprehensive JOSE (JavaScript Object Signing and Encryption) framework for Python. It supports JSON Web Tokens (JWT), Web Signatures (JWS), and Web Encryption (JWE), providing enterprise-grade security for issuing, signing, and encrypting web tokens.
📦 ssl
A standard Python module that provides access to Transport Layer Security (TLS) and Secure Sockets Layer (SSL) encryption. It wraps standard network sockets, allowing Python applications to securely transmit encrypted data over the internet, essential for HTTPS connections.

11. ⚙️ Standard Library, Core Utilities & Tooling

📦 array
A standard Python module that provides a space-efficient sequence type storing homogeneous C-style primitive data types (like integers and floats). Unlike standard lists, it enforces strict type constraints and uses significantly less memory, making it ideal for large datasets of uniform numeric data.
📦 base64
A standard Python module providing functions to encode binary data into ASCII characters and decode it back. It supports Base16, Base32, Base64, Base85, and Ascii85 formats, essential for transmitting binary files over text-based protocols like email or JSON.
📦 bisect
A standard Python module that provides support for maintaining a list in sorted order without having to sort the list after each insertion. It uses bisection algorithms to quickly find the correct insertion point, drastically reducing the computational overhead of frequent list updates.
📦 codecs
A standard Python module that provides a registry and base classes for encoding and decoding text and data streams. It handles character set transformations (like UTF-8, ASCII) and provides stream interfaces, ensuring proper text reading and writing across different operating systems.
📦 collections
A standard Python module that implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers (dict, list, set, tuple). It includes high-performance alternatives like `deque`, `defaultdict`, `Counter`, and `namedtuple` for optimized data manipulation.
📦 configparser
A built-in Python module designed to read and write configuration files structured like classic Windows INI files. It allows developers to easily parse sections, keys, and values, providing a simple and human-readable way to manage application settings without hardcoding them.
📦 contextlib
A standard Python module providing utilities for common tasks involving the `with` statement. It includes decorators and generator-based functions that make it incredibly easy to create custom resource managers, ensuring that setup and teardown operations are reliably executed.
📦 copy
A standard Python module providing essential functions for object duplication. It offers `copy()` for shallow copying (creating a new container but referencing the same internal objects) and `deepcopy()` for recursively duplicating all nested objects, ensuring complete isolation from the original.
📦 csv
A standard built-in Python module for reading from and writing to CSV (Comma-Separated Values) files. It handles various CSV dialects and delimiters, providing reader and writer objects that efficiently parse tabular data into Python lists or dictionaries.
📦 cython
An optimizing static compiler that translates Python code into highly optimized C code. By allowing developers to add static C-typing to Python scripts, Cython enables massive performance speedups for computationally heavy tasks, effectively bridging the gap between Python's ease of use and C's raw execution speed.
📦 dataclasses
A standard Python module that provides a decorator and functions for automatically generating boilerplate code in data classes. It automatically creates special methods like `__init__`, `__repr__`, and `__eq__` based on class-level type hints, drastically reducing code verbosity for classes that primarily store data.
📦 datetime
A standard Python module supplying classes for manipulating dates and times in both simple and complex ways. It provides robust objects for dates, times, timedeltas, and timezone-aware arithmetic, essential for scheduling, logging, and time-series data manipulation.
📦 decimal
A standard Python module that provides support for fast and correctly-rounded decimal floating point arithmetic. Unlike standard floats, it avoids binary floating-point rounding errors, making it strictly necessary for financial applications, accounting, and precise scientific calculations requiring exact decimal representation.
📦 dis
The standard Python disassembler module that converts compiled Python bytecode back into human-readable assembly-like mnemonics. It is a critical debugging tool used by advanced developers to analyze exactly how the CPython interpreter executes specific functions and code blocks.
📦 doctest
A standard Python testing module that searches for interactive Python sessions in docstrings and executes them to verify they work exactly as shown. It serves as both a lightweight testing framework and a tool for ensuring code documentation remains accurate and up-to-date.
📦 email
A standard Python package for managing email messages, including MIME (Multipurpose Internet Mail Extensions) standards. It allows developers to parse incoming raw email data, construct complex emails with attachments and multipart content, and handle various text encodings.
📦 enum
A standard Python module that provides support for enumerations. It allows developers to define a set of symbolic names bound to unique, constant values, making code more readable, type-safe, and maintainable when dealing with fixed sets of options like states, days, or categories.
📦 fractions
A standard Python module that provides support for rational number arithmetic. It allows users to create and manipulate exact fractions, performing operations without the floating-point rounding errors inherent in standard decimal mathematics.
📦 functools
A standard Python module providing higher-order functions and operations on callable objects. It includes powerful utilities like `lru_cache` for automatic memoization, `partial` for pre-filling function arguments, and decorators that simplify the creation of complex function wrappers.
📦 gc
A standard Python module that exposes the underlying CPython garbage collector. It allows developers to manually trigger garbage collection, inspect reference cycles, disable collection during performance-critical sections, and debug memory leaks caused by circular references.
📦 glob
A standard Python module that finds all the pathnames matching a specified pattern according to the rules used by the Unix shell. It simplifies file system operations by allowing wildcard searches (e.g., `*.txt`), making it easy to locate and list files across directories.
📦 gzip
A standard Python module that provides a simple interface to compress and decompress files using the GNU gzip algorithm. It allows developers to read and write `.gz` files transparently using standard Python file I/O methods, reducing disk usage and network transfer times.
📦 heapq
A standard Python module providing an implementation of the heap queue algorithm, also known as the priority queue algorithm. It allows efficient insertion and extraction of the smallest (or largest) element, making it ideal for scheduling tasks and finding the top N items in a stream.
📦 html
A standard Python module providing simple utilities for manipulating HTML. It primarily offers functions to escape and unescape HTML entities (like converting `<` to `<`), ensuring that user-generated text is safely rendered on web pages without causing cross-site scripting (XSS) vulnerabilities.
📦 http
A standard Python package collecting several modules for working with the HyperText Transfer Protocol. It provides constants for HTTP status codes, classes for handling HTTP connections, and a simple framework for building basic HTTP servers.
📦 importlib
A standard Python module that provides the implementation of the Python import statement. It exposes the internals of the import system, allowing developers to dynamically load modules, access package resources at runtime, and build custom importers for advanced plugin architectures.
📦 inspect
A standard Python module offering several useful functions to get information about live objects, including modules, classes, and functions. It can retrieve source code, inspect function signatures, and trace call stacks, making it essential for building dynamic APIs and debugging tools.
📦 io
A standard Python module providing core tools for working with various forms of I/O (input/output). It includes in-memory stream classes like `StringIO` and `BytesIO` that behave like files but operate purely in RAM, ideal for testing and manipulating data buffers.
📦 isort
A Python utility library that automatically categorizes and sorts import statements in Python scripts. It groups standard library, third-party, and local imports into distinct sections, formatting them alphabetically to improve code readability and maintain consistency across large codebases.
📦 itertools
A standard Python module containing fast, memory-efficient tools for working with iterators. It provides building blocks for creating complex data pipelines, permutations, combinations, and infinite sequences, allowing for highly optimized functional programming patterns.
📦 json
A standard Python module providing a JSON encoder and decoder. It allows Python objects like dictionaries and lists to be easily converted into JSON formatted strings, and vice versa, making it the standard tool for data exchange between Python backends and web frontends.
📦 logging
The standard Python module for logging events during application execution. It provides a flexible framework for emitting log messages with varying severity levels (DEBUG, INFO, WARNING, ERROR), routing them to different destinations (files, consoles), and formatting them for auditing and debugging.
📦 math
A standard Python module providing access to the mathematical functions defined by the C standard library. It offers functions for floating-point arithmetic, trigonometry, logarithms, and mathematical constants (pi, e), essential for standard scientific and engineering calculations.
📦 operator
A standard Python module that exports a set of efficient functions corresponding to the intrinsic operators of Python. For example, `operator.add(x, y)` is equivalent to `x + y`, allowing operators to be passed as arguments to higher-order functions like `map` or `sorted`.
📦 orjson
An extremely fast, highly accurate JSON parsing and serialization library for Python. Written in Rust, it outperforms standard libraries by supporting native serialization of complex Python objects (like datetime and dataclasses) and strict Unicode compliance, ideal for high-throughput APIs.
📦 os
A standard Python module providing a portable way of using operating system dependent functionality. It allows scripts to interact with the OS by reading environment variables, manipulating files and directories, managing processes, and executing system commands seamlessly across Windows, Mac, and Linux.
📦 pathlib
A standard Python module that offers object-oriented filesystem paths. Unlike manipulating path strings with `os.path`, `pathlib` represents paths as objects with intuitive methods for reading, writing, navigating, and matching files, significantly improving code readability across operating systems.
📦 pickle
A standard Python module used for serializing and de-serializing Python object structures (pickling). It converts complex Python objects (like custom classes or lists) into a byte stream for storage or transmission, and reconstructs them back into objects, though it is unsafe for untrusted data.
📦 platform
A standard Python module used to retrieve as much identifying data as possible about the underlying platform. It allows scripts to programmatically check the operating system, hardware architecture, and Python version, enabling cross-platform conditional logic.
📦 pprint
A standard Python module that provides a capability to 'pretty-print' arbitrary Python data structures. It formats complex nested structures like dictionaries and lists with indentation and line breaks, making raw JSON or deeply nested API responses much easier for humans to read.
📦 pydantic
The most widely used Python data validation library. It enforces type hints at runtime, providing powerful error messaging, deep object serialization, and automated settings management, forming the foundational data modeling engine for modern frameworks like FastAPI.
📦 pydoc
A standard Python module that automatically generates documentation from Python modules. It can extract docstrings, classes, and function signatures, displaying them directly in the terminal console or generating comprehensive HTML reference pages.
📦 pytest
A mature, full-featured Python testing framework designed to make writing simple, scalable tests easy. It supports fixtures, parameterized testing, and detailed assertion introspection, allowing developers to write highly readable test suites without boilerplate code.
📦 python-dateutil
A powerful extension to the standard Python `datetime` module. It provides highly flexible parsing of natural language date strings (e.g., '1st Jan 2023'), complex relative time deltas, and robust timezone handling, filling the gaps in standard date-time manipulation.
📦 python-dotenv
A Python utility that reads key-value pairs from a `.env` file and loads them as environment variables. It keeps sensitive configuration (like database passwords and API keys) separate from the source code, greatly simplifying application deployment and local development.
📦 pyyaml
The standard Python YAML parser and emitter. It allows Python applications to easily read and write YAML configuration files, converting between YAML text and Python dictionaries/lists seamlessly, widely used in Ansible and application configurations.
📦 random
A standard Python module that implements pseudo-random number generators for various distributions. It provides functions for generating random floats, integers, picking random elements from a list, and shuffling sequences, essential for simulations and games.
📦 re
The standard Python module for Regular Expression operations. It allows developers to search, match, and substitute complex string patterns, providing powerful tools for parsing log files, extracting data from text, and validating input formats (like emails or phone numbers).
📦 shutil
A standard Python module offering a high-level interface for file operations. While the `os` module handles basic file paths, `shutil` provides powerful tools to copy, move, rename, and delete entire files and directory trees, as well as create and extract archives.
📦 signal
A standard Python module providing mechanisms for handling asynchronous events (signals) sent by the operating system. It allows scripts to catch signals like `SIGINT` (Ctrl+C) to perform graceful shutdowns or `SIGALRM` for executing timed functions.
📦 string
A standard Python module providing a collection of string constants and a versatile `Template` class. It defines common character sets (like ascii_letters, digits) and allows safe, simple string substitution, useful for internationalization and simple text templating.
📦 struct
A standard Python module used for packing and unpacking data to and from C-style binary representations. It is essential for handling binary file formats, network protocols, and low-level memory operations where precise byte-level control over integers and floats is required.
📦 subprocess
A standard Python module that allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. It is the go-to tool for executing external system commands, shell scripts, and interacting with external software from within Python.
📦 sys
A standard Python module providing access to variables used or maintained by the Python interpreter. It exposes command-line arguments (`sys.argv`), standard I/O streams (`sys.stdin`, `sys.stdout`), and interpreter configurations, allowing scripts to dynamically interact with the runtime environment.
📦 tarfile
A standard Python module used to read from and write to compressed tar archives (`.tar`, `.tar.gz`, `.tar.bz2`). It allows developers to bundle multiple files and directories into a single archive or extract them, handling compression transparently without external tools.
📦 tempfile
A standard Python module that generates temporary files and directories securely. It ensures that temporary data is stored in the correct OS-specific cache folder and provides automatic cleanup handlers, preventing disk clutter and security leaks during script execution.
📦 threading
A standard Python module providing a high-level interface for running multiple threads concurrently within the same process. It is primarily used to overlap I/O-bound tasks (like network requests) to keep applications responsive, though it is limited by Python's Global Interpreter Lock (GIL).
📦 time
A standard Python module providing functions for time manipulation. It exposes low-level system clock access for retrieving the current time, measuring precise execution time deltas, and converting raw epoch timestamps into human-readable date/time strings.
📦 traceback
A standard Python module that provides a standard interface to extract, format, and print stack traces of Python programs. It allows developers to programmatically catch exceptions and log detailed error traces, aiding significantly in debugging and error logging.
📦 typing
A standard Python module that provides support for type hints. It introduces abstract base classes and generic types (like `List`, `Dict`, `Optional`) that allow developers to statically check code structure using tools like `mypy`, catching bugs before runtime.
📦 unittest
The standard Python unit testing framework, originally inspired by JUnit. It provides a structured approach to writing automated tests, supporting test fixtures, test suites, setup/teardown methods, and assertion methods for verifying code behavior.
📦 warnings
A standard Python module used to issue, filter, and manage warning messages. Unlike exceptions, warnings do not halt execution; instead, they alert developers to deprecated features or potential issues, allowing for fine-grained control over which warnings are displayed.
📦 xml
A standard Python package containing submodules for processing XML (Extensible Markup Language). It provides multiple parsing APIs (like ElementTree, DOM, and SAX), allowing developers to read, modify, and write XML data structures for configuration and web API integration.
📦 zipfile
A standard Python module used to read, write, append, and list ZIP archive files. It allows developers to compress and decompress files easily within Python scripts, handling `.zip` formats transparently without relying on external zip utilities.

12. 🔤 Text Processing & Natural Language Processing

📦 graphemeu
graphemeu is a utility library for handling Unicode grapheme clusters, which represent user‑perceived characters. It ensures correct string manipulation in languages and scripts where characters may consist of multiple code points, making it important for text processing, internationalization, and user interface development.
📦 nltk
The Natural Language Toolkit (NLTK), a comprehensive suite of open-source Python modules and data sets for symbolic and statistical natural language processing (NLP). It provides interfaces for tokenization, stemming, tagging, parsing, and classifying over 50 corpora and lexical resources.
📦 spacy
An open-source software library for advanced Natural Language Processing (NLP) in Python. Designed for production use, it provides blazing-fast tokenization, part-of-speech tagging, named entity recognition, and dependency parsing using pre-trained neural network models.

13. 🚀 Web Frameworks, APIs & Web Applications

📦 django
A high-level, full-stack Python web framework that encourages rapid development and clean, pragmatic design. It includes an ORM, authentication system, admin panel, and robust routing out-of-the-box, allowing developers to build complex, database-driven web applications quickly while adhering to the DRY (Don't Repeat Yourself) principle.
📦 extra-streamlit-components

Extra Streamlit Components — A community‑driven library that bridges external JavaScript and frontend components into Streamlit apps. It provides pre‑built custom UI widgets that are not natively available in Streamlit, allowing developers to enhance their web apps with richer interactivity and customized styling.

Key Features

  • Integrates external JavaScript and frontend components into Streamlit.
  • Offers pre‑built custom UI widgets beyond native Streamlit capabilities.
  • Enhances interactivity and user experience in Streamlit apps.
  • Supports customized styling for a polished frontend look.

Use Cases

  • Adding advanced UI elements (sliders, charts, interactive forms).
  • Embedding external JavaScript libraries into Streamlit workflows.
  • Creating visually rich dashboards and data apps.
  • Customizing app styling for professional presentation.
📦 fastapi
A modern, fast (high-performance) web framework for building APIs with Python 3.7+ based on standard Python type hints. It automatically generates interactive OpenAPI documentation and provides asynchronous request handling, making it one of the fastest frameworks for building scalable microservices.
📦 flask
A lightweight and highly extensible Python web framework classified as a 'microframework' because it does not require particular tools or libraries. It provides the bare essentials for web routing and request handling, allowing developers to plug in specific database or authentication modules as needed.
📦 gunicorn
A Python WSGI HTTP Server for UNIX. It is a pre-fork worker model ported from Ruby's Unicorn project, designed to take HTTP requests from a frontend proxy (like Nginx) and efficiently distribute them across multiple Python web application processes in a production environment.
📦 jinja2
A fast, expressive, and highly secure templating engine for Python. It allows developers to generate dynamic HTML, XML, or other markup formats by combining static templates with Python-like control structures and variables, widely used in frameworks like Flask and Ansible.
📦 starlette
A lightweight ASGI (Asynchronous Server Gateway Interface) framework/toolkit for Python. It is highly performant and modular, designed to build async web services from scratch, and serves as the core engine powering the high-level FastAPI framework.
📦 streamlit

Streamlit — A fast, open‑source framework for building custom web applications specifically tailored for machine learning and data science. It allows data scientists to turn Python scripts into highly interactive, shareable web dashboards in minutes, completely bypassing the need for frontend development.

Key Features

  • Transforms Python scripts into interactive web apps instantly.
  • Optimized for machine learning and data science workflows.
  • No frontend development required — focus stays on Python logic.
  • Open‑source and lightweight for rapid prototyping.
  • Supports rich interactivity and dynamic visualizations.

Use Cases

  • Creating interactive dashboards for ML models.
  • Building shareable data science reports and visualizations.
  • Deploying prototypes of AI/ML applications quickly.
  • Collaborating with non‑technical stakeholders via web apps.
📦 streamlit-aggrid

Streamlit AG Grid — A custom Streamlit component that integrates the powerful AG Grid JavaScript library. (AG stands for “Agnostic,” highlighting the grid’s framework‑independent design. The name reflects the library’s design philosophy: it is framework‑agnostic, meaning it can run without any specific frontend framework, while also offering dedicated integrations for React, Angular, Vue, and others. Agnostic → The grid engine is implemented in TypeScript with zero dependencies, so it can be used standalone or with any major JavaScript framework. This makes AG Grid flexible and portable, suitable for projects that don’t want to be locked into a specific frontend stack..) It brings highly performant, feature‑rich data tables into Streamlit apps, allowing users to sort, filter, edit, and group massive datasets directly in the browser.

Key Features

  • Seamless integration of AG Grid into Streamlit apps.
  • Supports sorting, filtering, grouping, and inline editing.
  • Handles large datasets efficiently with high performance.
  • Interactive, customizable tables with rich functionality.

Use Cases

  • Building interactive dashboards with advanced data tables.
  • Exploring and manipulating large datasets directly in the browser.
  • Creating editable tables for workflow automation.
  • Enhancing Streamlit apps with enterprise‑grade grid features.
📦 streamlit-authenticator

Streamlit Authenticator — A secure, easy‑to‑use authentication module specifically built for Streamlit applications. It provides pre‑built UI widgets for user login, registration, and password resetting, handling credential hashing and session cookies to secure sensitive dashboard areas.

Key Features

  • Pre‑built UI widgets for login, registration, and password reset.
  • Secure credential hashing to protect user data.
  • Session cookie management for authenticated access.
  • Lightweight integration with Streamlit dashboards.
  • Customizable styling to match app themes.

Use Cases

  • Restricting access to sensitive dashboard areas.
  • Adding user authentication to internal tools.
  • Building secure, shareable Streamlit apps for teams.
  • Managing user accounts without external auth providers.
📦 streamlit-cookies-controller

Streamlit Cookies Controller — A specialized Streamlit component that provides a high‑level interface for managing client‑side browser cookies. It allows Streamlit apps to safely set, read, and delete cookies, enabling persistent user sessions and personalized UI states across browser sessions.

Key Features

  • High‑level API for cookie management in Streamlit apps.
  • Supports set, read, and delete operations.
  • Secure handling of session cookies for authentication workflows.
  • Enables persistent user sessions across browser reloads.
  • Customizable storage for personalized UI states.

Use Cases

  • Maintaining login sessions in Streamlit dashboards.
  • Storing user preferences (themes, filters, layouts).
  • Building personalized, stateful web applications.
  • Securing sensitive areas of Streamlit apps with cookie‑based access.
📦 streamlit-cookies-manager

Streamlit Cookies Manager — A lightweight Streamlit utility designed to simplify cookie management. It acts as a bridge between the frontend browser and the backend Python script, allowing developers to retrieve, set, and persist user‑specific data (like dark mode preferences or tokens) via cookies.

Key Features

  • High‑level API for cookie operations (set, get, delete).
  • Bridges frontend browser state with backend Python logic.
  • Supports persistent storage of user preferences and tokens.
  • Lightweight and easy to integrate into Streamlit apps.

Use Cases

  • Saving user interface preferences (e.g., dark mode).
  • Persisting authentication tokens across sessions.
  • Maintaining personalized states in dashboards.
  • Building stateful, user‑aware Streamlit applications.
📦 streamlit-drawable-canvas

Streamlit Drawable Canvas — An interactive Streamlit component that renders an HTML5 canvas where users can draw, sketch, and annotate images directly in the browser. It captures the geometric drawings and returns them to Python as SVG or NumPy arrays, perfect for image labeling apps.

Key Features

  • Interactive HTML5 canvas embedded in Streamlit apps.
  • Supports freehand drawing, sketching, and annotations.
  • Exports drawings as SVG or NumPy arrays.
  • Ideal for labeling, annotation, and prototyping workflows.
  • Seamless integration with Python backend logic.

Use Cases

  • Image labeling and annotation tools.
  • Sketch‑based input for ML training datasets.
  • Interactive dashboards with custom drawing features.
  • Collaborative apps requiring browser‑side sketching.
📦 streamlit-float

Streamlit Float — A specialized Streamlit layout utility that allows UI elements to “float” or remain fixed in specific positions (like sticky sidebars or floating buttons) regardless of page scrolling. It leverages CSS positioning to bypass Streamlit’s default vertical flow.

Key Features

  • Supports floating and sticky UI elements.
  • Overrides Streamlit’s default vertical flow with CSS positioning.
  • Ideal for persistent navigation bars, side panels, or action buttons.
  • Lightweight and easy to integrate into existing apps.

Use Cases

  • Sticky sidebars for filters or controls.
  • Floating action buttons for quick interactions.
  • Persistent navigation menus across long dashboards.
  • Custom layouts requiring fixed positioning.
📦 streamlit-option-menu

Streamlit Option Menu — A custom Streamlit component that provides a highly customizable, horizontal or vertical navigation menu. It allows developers to build cleaner, more modern UI routing in Streamlit apps, bypassing the default radio‑button navigation for a more professional app feel.

Key Features

  • Customizable horizontal or vertical navigation layouts.
  • Modern UI routing beyond Streamlit’s default radio buttons.
  • Supports icons, labels, and styled menu items.
  • Lightweight integration with existing Streamlit apps.
  • Improves app usability with professional navigation design.

Use Cases

  • Building multi‑page dashboards with clean navigation.
  • Replacing radio‑button navigation with modern menus.
  • Adding sidebar or top‑bar navigation to apps.
  • Creating professional‑looking client‑facing applications.
📦 tornado
A Python web framework and asynchronous networking library originally developed by FriendFeed. By using non-blocking network I/O, Tornado can scale to tens of thousands of open connections, making it ideal for WebSockets, long-polling, and real-time web services.
📦 uvicorn
A lightning-fast ASGI server implementation built on top of `uvloop` and `httptools`. It is designed to run asynchronous Python web applications (like FastAPI and Starlette) in production, handling thousands of concurrent requests with minimal overhead.

14. ⚡🔀🧵 Asynchronous, Concurrency & Parallel Computing

📦 aiofiles
File support for asyncio handling local file I/O asynchronously.
📦 anyio
Asynchronous compatibility layer that works on top of both asyncio and trio.
📦 asyncio
The core standard library for writing concurrent, single-threaded asynchronous code in Python using async/await syntax. It provides an event loop, network I/O APIs, and synchronization primitives, enabling efficient handling of thousands of simultaneous I/O-bound tasks without the overhead of threading.
📦 celery
A robust, distributed task queue system for Python that allows developers to execute time-consuming asynchronous background jobs. It relies on message brokers like RabbitMQ or Redis to manage task scheduling, making it essential for scaling web applications and processing heavy workloads asynchronously.
📦 concurrent.futures
A standard Python module providing a high-level interface for asynchronously executing callables. It abstracts away the complexity of managing threads or processes by using `ThreadPoolExecutor` and `ProcessPoolExecutor`, allowing developers to easily parallelize I/O or CPU-bound tasks.
📦 dask
A flexible, open-source parallel computing library for Python. It scales existing Python ecosystems like NumPy, Pandas, and Scikit-learn by breaking down massive datasets into chunks and processing them concurrently across multiple cores or distributed clusters, enabling out-of-core computation.
📦 joblib
A lightweight Python library providing simple tools for pipelining Python jobs, specifically focusing on disk caching of function outputs and parallel execution. It is heavily used in scientific computing (like Scikit-learn) to avoid recomputing expensive intermediate results.
📦 multiprocessing
A standard Python module that supports spawning processes using an API similar to the threading module. It effectively bypasses the Global Interpreter Lock (GIL) by leveraging separate memory spaces, allowing Python code to achieve true CPU-bound parallelism across multiple processor cores.
📦 trio
A friendly Python library for async concurrency and I/O designed around structured concurrency.
📦 gevent
A Python library for concurrent programming using coroutines, providing a high-level interface for asynchronous I/O operations.
📦 dramatiq
A fast and reliable background task processing library for Python 3.
📦 ray
A unified framework for scaling AI and Python applications through distributed computing.