CPANscan

DBIx::SearchBuilder is a mature, DBI-backed Perl toolkit that makes it easy to express SQL queries and row handling in object form so you can build, page, sort, join and count result sets without hand-crafting raw SQL for every operation. You use it by subclassing SearchBuilder for a collection and providing a Record subclass for rows, then apply Limit, OrderBy, GroupBy, Join and paging methods to describe what you want and iterate over results with Next or grab them as an array. The module can emit the actual SELECT it builds for debugging, supports bind variables and query hints, handles distincts and complex joins, works with common DBD drivers including SQLite, Postgres, MySQL/MariaDB and Oracle, and is designed to be extended by application code. One noteworthy recent change is that the lazy-load column behaviour is now disabled by default so column fetching is simpler out of the box, though the configurable options for selective loading remain for advanced use.

Class::Mite is a minimal, high-performance object and role framework for Perl that bundles a tiny Role composer and a lightweight Class base. The Role component provides method composition with requires, excludes and with keywords and detects conflicts between roles. The Class component supplies a simple hash-based new constructor that automatically calls an optional BUILD hook and makes it easy to consume roles. The distribution also includes small helpers such as Class::More and Class::Clone and aims to give Moo and Role::Tiny style ergonomics with near-zero dependencies for developers who want a compact, fast way to build classes and role-driven behavior.

Aion is a modern, compact object system for Perl 5 that makes it easy to declare classes and roles with concise "has" properties and rich attribute options. It supports read/write/ro/wo permissions, required and constructor-less attributes, lazy defaults and builders, coercions, triggers, cleaners, custom accessors, predicates and clearers, plus role composition with with, requires and req. Aion includes a flexible type system and method signature checking via the :Isa attribute, and it adds extensible aspects so roles can introduce new attribute behaviors. It also provides dependency injection via the eon aspect working with the Aion::Pleroma container for autowiring services. If you know Moose, Moo or Mouse you will find Aion familiar but leaner and focused on extensible aspects and DI. The recent release improved pleroma autoinitialization by replacing the package variable with an Aion->pleroma accessor.

Kubernetes::REST is a lightweight Perl client that lets you talk to the Kubernetes API with a clean, high-level interface and typed IO::K8s resource objects instead of raw hashrefs. It covers common operations such as list, get, create, update, patch and delete, and it also supports streaming watches and pod logs plus pod port-forward, exec and attach when your HTTP backend can provide duplex transport. The transport is pluggable so you can use the default LWP backend, the lighter HTTP::Tiny backend, or plug in an async engine, and the client can dynamically load the cluster resource map to match your Kubernetes version. If you need idempotent deployments or automation, recent releases added ensure, ensure_all and ensure_only for create‑or‑update workflows that handle race conditions and server-side immutability for resources like PersistentVolumeClaim and Job while accepting either IO::K8s objects or plain manifest hashrefs.

Log::Fmt::XS is a drop-in subclass of Log::Fmt that swaps performance-critical parts into XS (C) code so emitting logfmt key=value log lines is noticeably faster. If you use Log::Fmt for structured, machine-friendly logging this module gives you the same behavior and API while reducing CPU overhead and improving throughput under load. It is intended as a transparent speed-up rather than a functional rewrite, so you can usually adopt it without changing your logging code. Be aware the author does not promise stable Perl version requirements forever, so future releases may require a newer Perl.

App::MARC::Leader is a lightweight base class for the marc-leader command line tool that decodes the 24-character MARC record leader and presents a human-friendly interpretation of its fields. It can read leaders from MARC XML or accept leader strings and relies on MARC::File::XML and MARC::Leader to do the parsing. The output shows labeled values such as record length, record status, type of record, bibliographic level, character coding scheme, indicator and subfield counts, base address of data and encoding level and it supports optional ANSI colored output for easier reading. The module exposes a simple new/run application API for embedding in scripts or building a CLI. Recent updates added a verbose mode (-v), made a leader string optional, and improved help text and documentation. This is a handy tool for librarians, metadata engineers and developers who need a quick, readable way to inspect or debug MARC leaders.

Convert::Pheno is a Perl toolkit for converting phenotypic data between common standardized models, letting you transform records between formats such as PXF (Phenopacket), BFF, OMOP, REDCap, CSV and JSON/JSON-LD either from code or via its command-line interface. It uses mapping files and configurable rules to preserve identifiers, ontological terms and visit/procedure details, includes memory-efficient streaming for large datasets and utilities for fuzzy matching and term mapping, and is designed to slot into pipelines that integrate clinical, research and registry data. The module is actively maintained by CNAG and the author requests citation of Rueda et al. 2024; the most recent releases refreshed the ICD‑10 database and reorganized internal components while adding improved search/fuzzy matching and a number of conversion refinements.

Enum::Declare::Common is a curated collection of ready-made enums for Perl built on Enum::Declare that saves you from retyping common constant sets like HTTP status codes and methods, weekdays and months, ISO country and currency codes, MIME types, CSS colors, timezones, permissions, log levels and more. Each submodule declares proper constants, export tags, and meta objects so you can introspect values, perform exhaustive matching, and validate or coerce inputs easily. The enums are registered as Object::Proto types at load time so you can use enum names directly as slot types with automatic coercion for things like case-insensitive lookups or numeric-to-name conversions. Avoid loading conflicting enums that share the same name across modules by importing only the tags you need, and note that this is the initial 0.01 release of the collection.

subst is a greple plugin that checks and optionally substitutes text in files using a dictionary of pattern-to-replacement pairs, where patterns can be full Perl regular expressions and replacements are plain strings. You feed it a dictionary file or inline data, or pass individual pairs on the command line, and it can report matches, produce statistics, and apply changes with diff, create, replace, or overwrite behaviors. It supports DEFINE named patterns, configurable handling of overlapping or included matches, optional line-folded matching for multi-line cases, and terminal color output. The distribution includes example dictionaries geared toward Japanese text normalization and style guides, so it is especially useful for enforcing style rules, normalizing variants like katakana spellings, or doing large scale, rule-driven search-and-replace across documents.

Text::Table::Read::RelationOn::Tiny is a compact parser that converts a simple two-valued text "cross table" (rows and columns with an "X" for related pairs and blank for not related) into a Perl-friendly representation of a binary relation on a set. It accepts input as a filename, filehandle, array of lines or string and builds an incidence matrix (a hash of hashes), an ordered element list and an element→index map, with options to customize the mark for related/not-related cells, to enforce format checks, and to allow tables that only contain a subset of the base set. You can predefine the base set and equivalent-element groups so output indices are stable and duplicate rows/columns are expanded automatically. Accessors let you retrieve the raw or name-keyed matrix, clone data, or request the matrix blessed into an object with a simple related(i,j) method. The module is forgiving about spacing and optional row separators but documents a small pitfall: element names beginning with a dash need a space after the first "|" to parse correctly.

RT-Extension-AWS-Assets lets you import AWS EC2 and RDS information into Request Tracker as managed assets so you can track instances and reserved instances from inside RT. It works with RT 6.0 and is enabled by adding your AWS IAM keys and the plugin to RT_SiteConfig. You configure which RT asset catalogs to use and map AWS fields to RT custom fields, then the extension creates or updates asset records for EC2 and RDS resources and for reserved instances in a separate catalog. A small web page in the RT UI helps you match reservations to actual resources by service, instance type and region, and the importer uses the Paws SDK to fetch data, so the named custom fields must exist before import. If you use RT to manage inventory, billing or resource allocation for AWS, this extension automates syncing AWS metadata into your asset database.

IO::Socket::Timeout adds per-operation read and write timeouts to existing IO::Socket objects such as IO::Socket::INET. You opt in by calling enable_timeouts_on on a socket and then set read_timeout and write_timeout on that socket. It also provides methods to disable or re-enable timeouts and to query whether they are active. When a timeout occurs the socket operation returns undef or an empty string and errno is set to ETIMEDOUT or EWOULDBLOCK so you can detect and handle timeouts in your code. On supported systems the module uses platform socket options to enforce timeouts and falls back to select when needed and you can force the select implementation with an environment variable. This is a lightweight, drop in way to avoid blocking reads and writes in networked Perl programs and it pairs well with retry helpers like Action::Retry when you need reconnect or retry logic.

Module::CheckLatestVersion is a small utility that helps Perl authors detect when a loaded module is not the newest release published to an authority like CPAN or DarkPAN. It exports a single function, check_latest_version, which you can call from a module or script to compare the package $VERSION with the latest known release and either warn or die if it is out of date. Checks are cached (default cache timeout comes from Cache::File::Simple) and can be skipped automatically in common automated environments or explicitly via environment variables or the do_check option, and you can control verbosity with a log_level setting. Recent updates added the do_check option and configurable logging. This module is useful when you want lightweight, automatic verification that users or deployments are running the most recent version of a module.

Google::RestApi is a Perl framework that makes it easy to work with Google REST services from scripts and applications by providing object-oriented wrappers for Drive v3, Sheets v4, Calendar v3, Gmail v1, Tasks v1, and Docs v1, so you can list and copy files, read and write spreadsheet ranges, create calendar events, send messages, manage tasks, and edit documents without dealing with raw HTTP calls. It centralizes OAuth2 authentication and configuration, assembles endpoint URIs via chainable resource objects, offers a low-level api method when you need it, and includes conveniences such as pagination callbacks, a per-request callback hook, throttling for development, and tutorial scripts to get you started. The core Drive and Sheets modules were hand-written and other endpoints were generated to fill gaps, so most common operations are covered and well tested but you may see rough edges on less-used calls. If you need programmatic access to Google services from Perl and can set up OAuth2, this module provides a practical, script-friendly API.

Math::MPC is a Perl wrapper around the MPC C library that gives you true multiple‑precision complex numbers and a full suite of complex arithmetic and special functions with explicit control over precision and rounding modes. It exposes almost all mpc routines from basic arithmetic and power to trig, exponentials, logs, roots, modular functions and utilities for conversion and formatted I/O, and it interoperates with Math::MPFR and GMP objects so you can mix real and complex high‑precision types. You can create blessed Math::MPC objects that clean up automatically or use non‑blessed in‑place objects if you want manual memory control and the module also overloads common operators so code looks natural while using the current default precision and rounding. Note that Math::MPC depends on the GMP, MPFR and MPC C libraries and must be built against them, and you can get crashes if you pass incorrect argument types or rely on overloaded operators to always preserve the sign of zero. The module is mature and actively maintained; recent releases improved tests and build support such as quadmath builds on Cygwin and added newer mpc functionality while keeping backward compatibility.

Software::Policies is a lightweight Perl toolkit for generating common repository policy and license files, including CONTRIBUTING, CODE_OF_CONDUCT, SECURITY and LICENSE, so you can quickly produce ready-to-use text in formats like Markdown. You create a Software::Policies object and call create with the policy name, class, version and any attributes and receive one or more policy files as plain text that you can drop into a repo or wire into Dist::Zilla automation. The module is handy for making public projects look complete and welcoming, follows common templates such as the Contributor Covenant and CPAN Security guidance, and integrates with Dist::Zilla helpers for automated generation and testing. It is a young, actively maintained project with incremental updates through version 0.003.

PDL::NDBin is a PDL-based Perl module for making multidimensional histograms and for running arbitrary per-bin computations on packed ndarrays. Its preferred object-oriented API lets you define axes and variables, use built-in actions such as Count, Sum, Avg, StdDev, Min and Max, or supply your own code or XS classes to be executed per bin. You can feed data piecewise so very large data sets can be processed without loading everything into memory, and the wrapper functions ndbin and ndbinning offer a concise procedural way to get n-dimensional histograms. The module supports autoscaling of axis ranges, fixed or user-provided variable-width grids, bad-value handling, and returns results shaped to the bin grid. It does not yet support weighted histograms or direct extraction of the raw list of values per bin. Recent releases are maintenance-focused with updates to improve compatibility and testing with modern PDL versions.

PDL::FFTW3 is a PDL wrapper around the FFTW3 library that lets Perl Data Language users compute fast N‑dimensional Fourier transforms on ndarrays, including complex↔complex and optimized real→complex transforms, with support for single and double precision and PDL threading for batched operations. It exposes functions like fft1..fftn, ifft1..ifftn, rfft1..rfftn and irfft1..irfftn (rNfftX is an alias) and supports in‑place transforms for complex data while requiring native complex PDL types for inputs and outputs. The module follows the common convention of normalizing the inverse transform so ifft(fft(x)) recovers x, handles the half‑spectrum layout for real transforms and documents the ambiguity in inverse real output sizing that you resolve by supplying an output ndarray of the desired length. You will need a system installation of FFTW3 to build and use it. Recent updates remove legacy PDL::Complex support so everything uses native complex types and the distribution was relicensed to match PDL itself.

IPC::Manager is a Perl library for passing structured messages between processes on the same machine without a central broker. You create or spawn a datastore and share a short connection string, then any process can connect by name and send or receive IPC::Manager::Message objects using a pluggable serializer and a choice of transport backends. Backends include filesystem-based options, atomic pipes, Unix sockets, various SQL databases, and in-memory or shared-memory variants, and the module can pick a suitable protocol automatically or let you specify one. It also provides helpers to spawn lightweight services and named worker processes so you can build simple service trees and request/response patterns while the manager handles client registration, delivery and cleanup. Messages are created and read through a small API so the module fits easily into scripts, daemons and test harnesses that need reliable local messaging. Recent releases focus on robustness and platform compatibility with fixes for Unix sockets on FreeBSD, improved message ordering, central message sorting, and additions like JSONFile and SharedMemory clients and a move to Cpanel::JSON::XS for more reliable JSON handling.

NKC::Transform::BIBFRAME2MARC is a Perl utility for converting bibliographic records from BIBFRAME XML into MARC XML using XSLT transformations. You instantiate the object, choose a transformation version (default is 3.0.0, several older versions are supported) or supply your own XSLT file, and call transform with BIBFRAME XML to receive MARC XML as a string. The module relies on XML::LibXML and XML::LibXSLT and will report errors if the XSLT file cannot be read or if unknown parameters are passed. It is a straightforward choice when you need to migrate or integrate BIBFRAME data with MARC-based systems.

Enum::Declare adds a simple declarative enum keyword to Perl so you can define named constants and a rich enum metadata object with minimal boilerplate. You write enums with optional attributes to make them integer sequences, string values that default to the lowercased name, or bitflags that auto-assign powers of two, and you can export constants into callers if desired. Variants may be given explicit values and integer enums auto-increment from the last explicit value, and every enum name also returns a meta object providing introspection like names, values, name/value lookup, validity checks, count, and a pairs list. The meta object also offers an exhaustive pattern matching helper that requires handlers for every variant or a wildcard default, which simplifies mapping enum values to behavior. This module is useful when you want clear, compile-time constants and convenient runtime introspection for enumerated types in Perl.

DarkPAN::Utils is a small utility library for working with a private CPAN mirror hosted on Amazon S3 and served via CloudFront, letting you download and parse the standard CPAN package index, fetch distribution tarballs, and extract individual files or Perl module sources for documentation or inspection. You can operate over the network by giving a base_url or work entirely locally by passing an Archive::Tar object, which is handy when a newly uploaded tarball is not yet available through the CDN. The module provides a parser for distribution paths, methods to fetch and cache 02packages.details.txt.gz, a find_module search over the in-memory index, fetch_package to download and load a tarball, and extract_module or extract_file to retrieve specific entries. It also includes a tiny command line front end and configurable Log::Log4perl logging via init_logger and log_level. Note that fetch_darkpan_index must be called before find_module and that network-based methods require base_url and will die on HTTP failures.

Crypt::OpenSSL3 is a Perl wrapper for OpenSSL 3 that gives Perl code direct access to modern SSL and cryptographic primitives. The distribution supplies modules for SSL connections, asymmetric keys, symmetric ciphers, message digests and MACs, key derivation functions, and X509 certificate handling, while the top-level Crypt::OpenSSL3 module focuses on error handling and build-time configuration and version introspection. It is a good fit when you need low level OpenSSL 3 functionality from Perl rather than a higher level abstraction. Recent releases expanded ASN.1 and X509 type coverage, improved compilation on clang and C++, and added a new sign_init_ex feature for digest contexts while gating X509 VerifyParam get_purpose on OpenSSL 3.5 and newer.

Cucumber::Messages is a Perl library that maps the Cucumber message protocol into native classes and gives you NDJSON serialization and deserialization so Perl programs can produce, consume, and manipulate Cucumber message streams. It provides an Envelope wrapper with to_json/from_json helpers and concrete message types for attachments, external attachments, Gherkin documents, pickles, test cases and steps, timestamps, exceptions and more, letting you build reporters, formatters, CI integrations or other tooling that reads or writes Cucumber messages. The API focuses on representing the protocol in memory and on the wire rather than execution details, and supports handling large binary artifacts via external attachments to avoid embedding heavy data. The code is released under the MIT license.

Log::Dispatchouli is a lightweight wrapper around Log::Dispatch that makes it very easy to add practical logging to Perl programs without wrestling with levels and categories. It can send output to syslog, stdout, stderr, files or to an in-memory array for tests and uses String::Flogger to format messages so you can log plain text, structured data, sprintf-style arrays or lazily evaluated coderefs. It also provides structured event logging via log_event using logfmt formatting, simple per-logger and per-message prefixes, proxy loggers for localized context, and handy controls such as debug, muted, pid tagging and fail_fatal behavior. There are testing helpers like new_tester and events, and convenience methods to get formatted strings without emitting them (flog_messages and fmt_event). Recent releases add optional use of Log::Fmt::XS for logfmt emission and fix an auto-use bug, and note that the older to_file option is deprecated and scheduled for removal.

SQL::SimpleOps is a Perl module that builds and executes common SQL operations across multiple database engines via DBI, supporting MySQL, MariaDB, PostgreSQL and SQLite3. Rather than parsing SQL it provides a convenient builder and executor for inserts, updates, deletes, selects, cursor-based paging and subqueries while allowing you to map friendly aliases to real table and column names to avoid recoding when schemas change. Results can be returned into hashes, arrays, scalars or handled by callbacks and the module offers flexible where and having expression formats, conflict/upsert support, per-call or global options for quoting, commit behavior, syslog or STDERR messaging and optional SQL file logging for auditing or recovery. It also includes cursor helpers that save paging state and features for reversed or indexed buffers to suit different retrieval patterns. Recent updates added select/having and buffer_reverse options and fixed several where-clause edge cases including correct handling of empty conditions as IS NULL, so it is a pragmatic choice if you want to reduce SQL boilerplate in Perl applications without writing engine-specific code.

Perl::Critic::Policy::Security::RandBytesFromHash is a linting rule for Perl::Critic that finds a common but unsafe pattern where programs try to produce random bytes by hashing predictable inputs such as rand, time, process id, reference addresses or internal counters. The policy explains why hashing those seeds with functions like MD5 or SHA gives a false sense of security and can be guessed by attackers, and it points developers toward secure alternatives such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. It flags calls that look like hash functions or joins built from insecure sources and may sometimes report the same construct more than once. The module is aimed at catching legacy and new code that uses this risky shortcut and requires Perl 5.24 or later; the package is newly released as v0.1.0.

Amazon::API is a Perl base class that provides a lightweight, generic gateway for calling AWS services and for building small, focused service clients. You can use it directly for ad hoc requests, subclass it to expose a handful of methods for a single service, or use the included amazon-api tool to generate full service and shape classes from Botocore metadata so that requests and responses are serialized correctly. The module handles signing, content-type selection, pagination and optional automatic decoding of JSON or XML responses and integrates with Amazon::Credentials for flexible credential sourcing. It is a good fit if you want to install or use only the AWS APIs you need rather than a full SDK, but it expects some familiarity with AWS API payloads and requires generating shape classes for full Botocore-based support. Recent releases replaced LWP::UserAgent with a project-specific HTTP::UserAgent implementation and removed an unused accessor dependency while continuing to refine Botocore serialization and pagination behavior.

Devel::CallParser provides an XS-level C API that lets extension authors attach custom argument parsers to Perl subroutines so calls can be parsed by C code instead of relying solely on Perl's default parser. It supplies header files and linkable objects at build time and exposes a central cv_set_call_parser primitive plus a suite of helper parsers for parenthesised, nullary, unary, list, block-and-list and prototype-driven argument forms, making it useful when you need to implement nonstandard call syntax or custom compile-time argument handling in an XS module. The facility is most effective on modern Perls, with limited support on Perl 5.11.2–5.13.7 and full functionality on 5.13.8 and later, and it only triggers for unqualified subroutine names. The author has fixed portability and core-interaction issues in recent releases so generated headers work across API-compatible Perls and several incompatibilities with older Devel::Declare and Data::Alias versions have been addressed.

Log::Report is a Perl framework that unifies three related concerns into one API: structured logging, exception handling, and internationalized messages. It gives you easy message constructors like __x and __n that build objects with delayed interpolation and translation, short helper functions such as error, info and trace to replace die/warn, and a dispatcher system that can send each report to multiple back-ends such as files, syslog or Log::Log4perl with configurable verbosity modes. It also provides a try block that captures exceptions as rich message objects so callers can inspect, rethrow or route them without losing untranslated parameters or context. Use it when you want consistent multi-destination logging, language-aware user output, or cleaner exception semantics across modules and applications, and opt for Log::Report::Optional when you need a very lightweight footprint. Recent releases (current 1.44) renamed exception "classes" to "tags" in a backwards compatible way and ensure converted die messages receive a 'die' tag.