CPANscan

Finance::Quote is a mature Perl library that pulls stock, mutual fund and bond quotes from dozens of exchanges and web services around the world, returning a simple table of standard fields such as price, volume, currency, date and dividend info so you can integrate live market data into scripts or applications. You create a quoter object, call fetch with a method name and symbols, and the module consults one or more exchange-specific backends and optional currency conversion modules to produce the results, with configurable timeouts, required-label checks and failover behavior. Currency conversion is pluggable and some backends require API keys, and the module includes handy utilities for date/time normalization, CSV parsing and number scaling. The recent 1.71 release fixes NZX JSON mapping and updates IndiaMutual NAV parsing to an 8-column format with Plan and Option fields and adds SIF support while removing some Morningstar modules. Be aware that you cannot control the internal failover order and results are presented as a two-dimensional hash, which some users find less convenient than nested references.

DateTime is the canonical Perl object for representing and manipulating calendar dates and times, providing constructors like new, from_epoch and now, rich accessors for year/month/day/hour/minute/second and nanoseconds, and locale-aware formatting via strftime and CLDR patterns. It understands time zones including a special "floating" zone, handles leap seconds, offers duration-aware math and subtraction that produce DateTime::Duration objects, and overloads arithmetic and comparison so you can add durations and sort datetime objects naturally. The module is careful about tricky edge cases such as ambiguous or non-existent local times around daylight saving transitions and documents recommended practices like doing calculations in UTC or using floating time for simple date math, and it deliberately does not attempt free-form date parsing so you should use DateTime::Format::* modules for input parsing. Recent documentation updates clarify that truncate can raise a fatal error when truncating to a unit produces a local time that does not exist because of a midnight DST transition, and that rfc3339 output does not include nanoseconds. If you need a robust, well-tested date/time core for a Perl application that must handle time zones, locales, leap seconds and various calendar math, DateTime is the right choice.

PDL::Fit::Levmar brings the Levenberg-Marquardt nonlinear least-squares solver into Perl's PDL environment so you can fit models that are nonlinearly dependent on parameters using a high performance C library. It wraps the liblevmar code and supports analytic or numeric Jacobians, box, linear and inequality constraints, parameter fixing, broadcasting and single or double precision runs, and it returns optimized parameters, a covariance matrix and detailed diagnostics. Model functions may be provided as Perl subs for convenience or as pure C or in a small "lpp" description language that is translated to and compiled as C on first use for much better speed. Some advanced constraint options require building with LAPACK and BLAS, threading is reportedly reentrant though not heavily tested, and there are a few known quirks with workspace and some broadcasting cases in the bundled levmar-2.6 code. If you need a robust, fast Levenberg-Marquardt fitter integrated with PDL and want the option to trade ease of use for compiled performance, this module is highly relevant.

Git::Native is a Perl interface to libgit2 that lets you work with Git repositories from Perl code without forking the git executable, using FFI::Platypus and Moo-based classes to open, init, clone, read and write objects, and build commits directly in-process. It hands back Git::Native::Repository objects for operations like open, open_ext, init and clone, and provides conveniences such as creating blobs, building trees, validating reference names, and adjusting libgit2's config search paths. Because it talks to libgit2 it is typically faster and more self-contained than shelling out to git and is a good fit for scripts, services or test suites that need programmatic Git access. A few limitations are noted by the author: cloning currently only supports unauthenticated URLs and not bare clones, opening can fail due to libgit2's ownership checks in some container or CI setups, and changing the config search path is process-global and only affects repos opened after the change. If you want to avoid repeated git subprocesses and prefer an in-process Git API from Perl, Git::Native is worth considering.

Stats::LikeR is a high-performance Perl toolkit that brings many of R's familiar data-frame operations, statistical tests and modeling tools into Perl, implemented in XS for speed and numerically validated against R and SciPy where possible. It understands four common table shapes (array-of-arrays, array-of-hashes, hash-of-arrays and hash-of-hashes) and gives you fast, memory-conscious primitives for reshaping and joining data (concat/rbind, merge, melt, pivot_table, aoh2hoa, hoa2aoh, aoh2hoh), grouped aggregation (agg, group_by), row filtering and column assignment (filter, assign, map_cell), binning and ranking (qcut, rank, quantile), missing-value handling and interpolation (dropna, fillna, ffill, bfill, interpolate), I/O for delimited files and .xlsx and LaTeX output (read_table, write_table), plus a large suite of statistics from basic summaries to advanced inference and models (mean/median/sd/skew/kurtosis, t_test, wilcox_test, chisq_test, fisher_test, anova/aov, oneway_test, kruskal_test, glm, lm, coxph, survfit, logrank_test), diagnostic and effect-size tools (auc/roc/bedroc, cramers_v, cohen_d, smd, vif, eta_squared), distribution and utility functions (pnorm/qnorm, pt/qt, pchisq/qchisq, pbinom, density, hist, sample, runif/rnorm/rbinom) and helpers for table housekeeping (vals, colnames, rownames, nrow/ncol, view). It includes an interactive help function h() and aims to match R behavior closely while being tuned for performance, so it is a good fit if you want R-like analytics inside Perl scripts or pipelines. Note that some routines follow R conventions exactly so ANOVA here is sequential (type I) and term order matters, aov assumes normality, and predict has limits around automatic factor re-expansion, all of which are documented in the module.

Git::Libgit2 is a thin, low-level Perl bridge to the libgit2 C library built with FFI::Platypus and Alien::Libgit2, intended for callers who need direct access to libgit2's API from Perl. It exposes init/shutdown, version and error helpers, raw OID conversion, a broad set of object/repo/revwalk/remote/diff and config bindings, plus many libgit2 constants so you can call the C surface almost verbatim; check_rc converts negative libgit2 return codes into rich exceptions. This module deliberately mirrors the C ABI, so callers must manage lifetimes and buffers the same way C code would and should consider Git::Native if they want an idiomatic, RAII-style Perl wrapper. Recent releases add safer probing for struct layouts (fetch_options_prune_offset) to avoid subtle cross-version memory bugs and a new cert_hostkey_offsets helper to read host-key hashes from certificates used in transport callbacks.

Alien::Libgit2 is a helper module that makes the libgit2 C library available to other Perl modules by either using a suitable system installation or building a bundled copy. It prefers a system libgit2 discovered via pkg-config when the version is 1.9.3 or newer and otherwise builds libgit2-1.9.3 from the included source with CMake so installs work even on air-gapped machines. The module exposes the compiler and linker flags needed by XS consumers and the dynamic library information needed by FFI-based modules so they can link against libgit2 without manual configuration. Building the bundled copy requires cmake, a C compiler, pkg-config and optional OpenSSL and libssh2 headers for HTTPS and SSH support. You can force a system or bundled install via ALIEN_INSTALL_TYPE and common users of this module include Git::Libgit2 and Git::Native.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration bundle that captures the author's preferred defaults for building, testing and releasing Perl distributions so you can get a sensible, feature-rich dist.ini with minimal fuss. It wires together versioning and changelog management, pod generation or task weaving, Git and GitHub (or Gitea/Forgejo) metadata and release hooks, optional Alien and XS support, Docker build/release helpers, install/release automation and a shared GitHub Action for CI, and exposes a simple set of options like author/authority, release_branch, tag_format, include_readme, no_github/no_cpan, xs/xs_alien/alien_build, docker_image/docker_tags and run_* hooks so you can tweak behaviour without handcrafting many plugins. The bundle also adds conveniences such as adoptme metadata, a generate_license mode that enforces a committed LICENSE file, and a version_finder to limit which files get $VERSION rewrites. Recent noteworthy updates include expecting LICENSE to be committed to the repo by default with an option to restore generated-license behavior, improved handling so bumped executables are committed with releases, and tighter Docker integration that requires Docker::API 0.104 so failed image builds emit useful logs.

Punk::TOTP is a compact Perl implementation of HOTP/TOTP one‑time passwords that helps you add time- or counter‑based two‑factor authentication to web apps, offering secret generation, RFC‑compatible otpauth:// provisioning URIs for QR codes, code generation and a verifier that is replay‑safe by design. It includes base32 encode/decode utilities, performs HMACs via File::Raw::Hash so you do not need heavyweight crypto dependencies at install time, and checks codes in a constant‑time window with configurable algorithm, digits, period and skew while refusing malformed input early. Because verification requires the shared secret, you must store secrets (and a last_counter value for replay protection) securely; the module documents that requirement and provides mechanisms to update counters on successful logins. Recent releases fixed security issues around failed‑attempt tracking and identifier comparisons and added server‑side attempt windows and optional schema provisioning, and the latest change ensures default challenge pages include CSRF fields and are sent with no‑store cache headers. If you need a straightforward, standards‑compliant TOTP/HOTP toolkit for Perl without pulling in external crypto libraries, Punk::TOTP is a practical choice.

Amazon::Credentials is a small Perl utility for discovering and returning AWS credentials from a variety of places so your script does not have to hardcode keys. It searches configurable sources in order, including environment variables, container endpoints (ECS, Fargate, Lambda, EKS pod identity), EC2 instance metadata (IMDSv2 by default), OIDC web-identity tokens (EKS IRSA and GitHub Actions), and local AWS config/credentials files, and it can also fetch SSO role credentials or run an external credential_process. You control the lookup order, timeouts, caching behavior and logging, and there is a simple CLI for ad hoc use. The module takes security seriously by storing credential values inside closures rather than as plain object fields so dumps and serializers do not reveal secrets, and it offers options to minimize how long credentials live in memory while reminding you that Perl cannot guarantee immediate memory zeroing. It does not automatically resolve profiles that require assuming a role via other profile credentials, and it has not been tested on Windows. Recent 1.3.x work focused on packaging and build improvements while an earlier 1.3.0 release made a notable security change by replacing on-disk encryption with closure-based in-memory protection.

String::License scans a text string for license statements and returns a normalized name or an SPDX license expression, making it easy to extract or standardize licensing metadata from source files or other documents. You create a String::License object with the string to inspect and can supply a naming helper to control the output format; by default it produces SPDX-style names but you can plug in custom naming schemes. The primary method as_text yields either an SPDX expression or a short descriptive label, so the module is useful for automated license checking, metadata generation, or cleaning up inconsistent license notices. Note that initializing naming schemes can be relatively expensive, so reuse of a naming object speeds repeated processing. The code is based on the KDE licensecheck script and is distributed under the GNU Affero General Public License.

Sim::OPT is a Perl framework for optimization and parametric exploration of simulation models that use text-file inputs and outputs. It favors problem decomposition by running overlapping block-coordinate searches that can be executed sequentially or in parallel, so you can use Gauss-Seidel or Jacobi style updates when searching across parameter subspaces. The distribution bundles modules to morph model parameters, build metamodels from sparse multidimensional data, convert 2D parallel coordinates into AutoCAD instructions, and to work specifically with ESP-r building performance simulations. Workflows are controlled with a simple configuration file that declares search blocks, iteration counts and starting points, and the tool can either launch simulations or operate on pre-simulated results while supporting factorial, star and DOE-style searches plus options to randomize search order. Installation is via cpanm and a command-line wrapper called opt is provided along with annotated examples to help you get started. Sim::OPT is dual licensed with an open-source core under GPL v3, runs on Linux, and the initial h2xs-generated release 0.507 was packaged in December 2025.

Crypt::JWS::OpenSSL is a Perl module for creating, inspecting, and verifying compact signed JSON Web Tokens using OpenSSL-backed cryptography. It supports HMAC algorithms (HS256, HS384, HS512) plus RSA and ECDSA variants including RS*, PS* and ES* and accepts secrets as raw shared keys, PEM-encoded keys, or JWK structures. Typical workflows use encode to produce a signed JWT from a header and claims, decode_unverified to extract header and claims and obtain a reusable verifytoken, and verify to check the signature once you have the appropriate public key or secret. The module records failure reasons in last_error by default and can be set to throw exceptions via throw_errors, it also reports availability of RSA padding modes and allows you to supply your preferred JSON backend. This is the initial 0.001 release published on 2026-08-30.

Punk::Queue is a durable, multi-process job queue for Perl with a C core that stores jobs as rows in a database and lets worker processes claim, run and record them atomically for high throughput. It ships with SQLite and PostgreSQL backends, pools DB connections safely across forks, and gives a compact API to register task bodies, enqueue jobs with priorities, delays, parents and dedupe keys, and to dequeue and perform work in workers. The system includes retries with randomized exponential backoff, layered timeouts, per-job logging that survives retries, repair routines for crashed workers and orphaned jobs, simple lease and counted locks, broadcast messages to workers, and list/stats/history endpoints suitable for an admin UI. Because the queue guarantees at-least-once delivery, every task must be written idempotently so reruns do no harm. Recent changes simplified the admin UI to ordinary page loads instead of a vendored SPA and vendored FontAwesome, plus a number of stability and portability fixes in the C layer and supervisor logic.

String::Copyright is a small Perl utility that scans a block of text for copyright lines and rewrites them into a consistent, human readable form. It provides a copyright() function that returns normalized copyright statements and lets you control scanning with threshold, threshold_before and threshold_after options to stop parsing after a number of noncopyright lines. You can also supply a custom format callback to render the output in your preferred style. The module works on decoded Perl strings rather than raw bytes so input must be decoded to the correct encoding before use. It recognizes ASCII and several common misdecoded forms of the copyright sign and will try to normalize them while emitting a warning if misdecoding is detected. This module is handy for tidying license headers or extracting copyright information from source files and other text.

Regexp::Pattern::License is a ready-to-use collection of regular expressions for recognizing and extracting software license names, grants, clauses, and other license-related traits from plain text. Built to fit the Regexp::Pattern convention, it provides pattern objects for individual licenses (GPL, MIT, Apache, BSD and many others), versioned variants, trait fragments like "or later" and "licensed under", combinations and groups, and multiple scope levels from single lines to multi-section blocks. You can drop these patterns into text scanners, search tools, metadata extractors or linting scripts to detect or normalize license references without writing complex regexes yourself. The module is actively maintained and mature, and recent updates tightened several patterns to reduce false positives, improved internal trait patterns and documentation, and fixed a few typos and edge cases such as better disambiguation of MIT versus NTP text.

Punk::Mailer converts a simple Perl hash representing an email into RFC 5322 and MIME compliant message bytes and helps you send them through configurable transports. It assembles text and HTML into multipart bodies, wraps attachments into the proper mixed parts, picks sensible encodings and always uses UTF-8 for text. The module strictly validates addresses and header values to prevent header injection, encodes non-ASCII display names and subjects, streams attachment files in chunks so large files do not blow memory, and can stream the final bytes to a callback if you prefer. You create a Punk::Mailer with a chosen transport like SMTP, sendmail, resend, capture or log, and it checks all options up front so configuration errors fail early. The send method hands a validated message to the transport and returns a result object rather than throwing on delivery issues, making the module a practical choice for web apps and services that need reliable, standards-safe outbound mail and integrates with Punk via Punk::Plugin::Mailer.

OpenMP::Simple is a lightweight Inline::C helper that makes it easy to use OpenMP from Perl by bringing in the compiler and linker settings discovered by Alien::OpenMP and by auto-including a convenience header with macros and helper routines. It provides macros to apply common OpenMP environment variables from %ENV or from the companion OpenMP::Environment module so your Inline C code can set thread counts, scheduling, device selection and related runtime options, and it also offers functions to count, verify, and convert Perl arrays to native C arrays for numeric and string data. This module is most relevant if you embed C in Perl with Inline::C and want straightforward, validated control of OpenMP runtime settings and less repetitive Perl-to-C data handling. Portability depends on a compatible Perl, C compiler and OpenMP runtime discovered by Alien::OpenMP, some conversion helpers are still experimental, and code should avoid calling the Perl API from OpenMP worker threads where possible. Recent releases expanded CI and platform testing, corrected OMP_SCHEDULE, OMP_DYNAMIC and OMP_NESTED handling, improved threaded string conversion safety, and added array counting and verification helpers.

Sys::OsRelease::Lite is a small, dependency-light helper that reads the standard /etc/os-release file and exposes the operating system and distribution metadata to Perl programs so they can detect the platform, distribution family and other identifying fields. It provides a single shared instance (accessible via the exported osrelease() function or class methods) and convenient read-only accessor methods for the standard os-release attributes such as id, id_like, name and version, along with general get/has_attr calls for any nonstandard fields. If no os-release file is present the module does not error and returns empty attributes while platform() falls back to Perl's Config information, making it safe for scripts that must run across Linux, BSD and older Unix environments. Sys::OsRelease::Lite is the same codebase as Sys::OsRelease but packaged to support older Perl releases back to 5.10, so pick the non-lite Sys::OsRelease on modern Perls and use the Lite variant when supporting legacy installations; its minimal setup makes it handy for installers, container tooling and other code that needs to know the host OS.

Sys::OsRelease is a small utility for reading the standard /etc/os-release file and exposing the operating system and distribution details in a simple Perl API, so your scripts can detect distro name, version and related attributes without parsing files yourself. It provides a singleton instance with easy accessors for the standard os-release fields and a platform() helper that prefers common ID_LIKE values and falls back to Perl's Config when no os-release file exists, and it also exports a convenience osrelease() function for straightforward use. The module keeps dependencies to a minimum so it works well in lightweight or containerized environments and there is a Sys::OsRelease::Lite variant packaged for older Perl releases. Recent maintenance releases clarified behavior on systems without an os-release file and fixed a couple of edge case bugs related to configuration initialization and version handling. If you need reliable, low-overhead OS detection in Perl programs, this module makes the common os-release information easy to read and use.

Dist::Zilla::Plugin::Docker::API builds and publishes Docker/OCI images as release artifacts alongside a Dist::Zilla-built distribution, letting you package your Perl project into a container image, apply a set of tags for local verification, and optionally push those tags to a registry during release. It speaks to the container engine via the Docker Engine HTTP API so no docker binary is required and it works with alternatives such as rootless Podman when you point DOCKER_HOST at the engine socket. The plugin runs an early engine-version precheck and can preflight registry credentials for releases, supports configurable Dockerfile name, build args, labels, platforms and tag templates, and exposes switches like build_load, release_push and release_load to control loading and pushing behavior. Registry credentials are resolved only from the auths block of ~/.docker/config.json or DOCKER_CONFIG, so podman’s own auth file and external credential helpers are not consulted. Use this plugin when you want Dist::Zilla to produce and manage container images for development testing and automated publishing as part of your release workflow.

API::Docker is a pure-Perl client for the Docker Engine HTTP API that gives Perl programs a clean object-oriented way to manage containers, images, networks, volumes and exec/system operations without shelling out to the docker binary. It talks to a daemon over a Unix socket or plain TCP, automatically negotiates the highest API version supported by the server, and works with any engine that implements the Docker API such as Podman. The interface exposes resource-specific classes and convenience methods for common tasks like listing, creating, starting and removing containers, pulling and pushing images, and streaming build or events output. Note that TLS is not implemented and asking for it will croak, so you should terminate TLS outside the client if you need encryption. The recent 0.003 release cleaned up streaming behavior and error reporting so failed builds, pulls and pushes surface as exceptions with preserved event streams, and log/exec output is now demultiplexed into stdout/stderr frames, making programmatic use of progress and logs much more reliable.

App::Netdisco is an open source, web-based network management application that inventories and maps your switches and routers by collecting SNMP data into a PostgreSQL database and presenting it via a built-in web UI and backend daemon. Network engineers can use it to locate a host by MAC or IP and see the switch port it sits on, change port state or VLAN and PoE settings, run discovery and polling jobs, and produce inventory and topology views for troubleshooting and reporting. It installs on a standard Perl/Postgres stack and can be run in a self-contained user environment or via provided container images, with command-line tools for deployment, discovery and job control and a DBIx::Class API for integrations and plugins. The project is actively maintained and recent releases modernized the frontend libraries, improved SNMP support (including better Cisco WLC handling), and added performance and API refinements, so it is a good fit if you need an open, extensible tool to discover, track and control layer‑2/3 network devices.

WWW::Spotify is a Perl client that wraps the Spotify Web API and exposes catalog, track, artist, playlist and user-library operations as simple methods that mirror the HTTP endpoints. Calls return raw JSON or decoded Perl data structures and there is a convenient get() helper that uses JSON::Path to pull specific values from the last response. The module supports OAuth for user-level actions and provides helpers to build the authorization URL, exchange authorization codes and refresh tokens so you can create and modify playlists, save or remove library items and perform other authenticated operations. You can supply your own LWP-based user agent and tune behavior with options such as auto_json_decode, die_on_response_error and a custom request handler. The author has kept the module current with Spotify API migrations through 2026, consolidating library endpoints and renaming playlist tracks to items; deprecated endpoints are retained with warnings and recent releases added a working authorization-code flow while introducing a breaking change where create_playlist no longer accepts a user_id argument. The module requires Perl 5.24 or newer and includes mocked tests plus optional live tests to help you develop safely.

DBD::Excel is an alpha-quality DBI driver that lets Perl programs treat Excel .xls worksheets like SQL tables so you can prepare and execute SQL against spreadsheets to read, create and update sheets. It leverages Spreadsheet::ParseExcel to read files, Spreadsheet::WriteExcel to write them and SQL::Statement as the query engine, and it maps each worksheet to a table using the first row as column names. The driver supports options to declare temporary or virtual table ranges at connect time, can list Excel files or sheet names, and provides attributes to skip hidden rows and control case sensitivity. Some DBI features are not implemented, AutoCommit is always on, and the module currently lacks date/time and formatting support and only handles single-table SELECTs, so it is best suited for simple SQL-style access, scripting tasks and lightweight Excel import/export work rather than complex joins or full-featured Excel formatting.

JSON::Schema::Modern is a Perl evaluator for JSON Schema that lets you validate JSON data or Perl data structures against modern JSON Schema drafts, including the current 2020-12 draft, with support back to draft-4. It makes it easy to load and register schema documents, run validations that return a rich Result object containing errors, annotations and optional default values, and to customize behavior with options such as strict mode, short-circuiting, format and content validation, and caching for large documents. You can extend it with custom format validators, media-type decoders and encodings, add custom vocabularies for metaschemas, and integrate it into workflows like OpenAPI validation. The module is actively maintained and recent releases improved reference handling by tracking unresolved remote references for later verification and fixed an error in reference checks. The author notes some practical limitations around Perl type mapping and untrusted schemas, so it is best used with decoded JSON or trusted schema sources.

Complete::XWindowManager is a tiny helper library for adding autocompletion around X Window System targets. It exposes two non-exported routines that return completion candidates for existing X window IDs and for window titles, each intended to be called with the current word being completed and plugged into the Complete framework or into custom completion code. If you are building command line tools or shell completions that need to let users pick windows by ID or by title, this module supplies the simple lookup routines to generate those suggestions.

PAGI::FastAPI is an asynchronous, FastAPI-inspired micro-framework for modern Perl that gives you non-blocking request handling on the PAGI spec, Type::Tiny driven validation for query, body and path parameters, a simple dependency injection style, and automatic OpenAPI 3.1 and Swagger UI documentation so you can build typed, documented HTTP APIs quickly. It includes route helpers for the usual verbs, WebSocket and Server-Sent Events streaming, middleware and CORS integration, pluggable authentication via dependencies or the companion PAGI::FastAPI::Security distribution, rate limiting, bot protection, CSRF helpers, response helpers for redirects and files, and a lightweight async queue facade. The recent 1.7.0 release adds proper RFC 7578 multipart/form-data parsing with form_data() and uploaded_files() context helpers, a $c->background API for fire-and-forget async tasks that continue after a response is sent, richer per-route OpenAPI metadata and Swagger UI customization options, plus a file response helper. Note that uploaded files and file_response currently read file contents into memory so you should plan request size limits accordingly. If you want a modern, type-safe, async-first framework for building Perl microservices with built-in docs and streaming support, this module is worth exploring.

Object::Proto is a fast, alternative object system for Perl that replaces ordinary bless-based objects with compact, array-backed objects and optional prototype chains while keeping normal method dispatch, isa and can intact. You declare classes with object or Object::Proto::define and list typed properties with modifiers like required, readonly, default, lazy, builder, predicate, clearer, weak and private, and the module generates very fast accessors and constructors that accept positional or named arguments. It supports inheritance, multiple inheritance, roles, method modifiers, BUILD and DEMOLISH hooks, singletons, cloning, lock/freeze semantics and importable function-style accessors for maximum throughput. Types include several built-ins and can be extended from Perl or registered at the XS/C level for near-zero runtime cost. If you need compact, high-performance objects with rich attribute semantics and familiar Perl method behavior, Object::Proto is a practical choice.

ClamAV::Clamd is a lightweight Perl client for talking to a clamd antivirus daemon so your app can ask a local scanner to check uploads without linking libclamav or carrying the signature database. It supports scanning raw bytes, file paths, or open file descriptors and can hand a descriptor to clamd so the scanner reads a file without needing filesystem permission to the path. The module provides both blocking convenience methods and a small non‑blocking state machine you can drive from an event loop, and every scan returns a Verdict object with four distinct outcomes: clean, infected, unscannable, or error, which helps you avoid treating failures as safe. It prefers UNIX domain sockets for descriptor passing, exposes useful controls for timeouts and size limits, reports structured error codes when things fail, and can tell you whether fd‑passing actually works on the platform. Recent fixes make live test runs opt‑in to avoid talking to someone else’s daemon and ensure commands disabled in clamd (version, stats, reload) return a proper ERR_UNAVAILABLE response rather than being misinterpreted as data.