CPANscan

MOP4Import::Declare is a toolkit for building custom Perl exporters that turns use/import arguments into structured "declare_*" method calls so you can add pragmas, symbols, methods and variables to a target package in a consistent way. It dispatches incoming import items by type so a bare "-name" triggers declare_name, an arrayref like [name => @args] invokes declare_name with arguments, ordinary names and sigils are handled like traditional exports, and code refs can act as callbacks. A small Opts object carries caller information into each handler and the module provides helpers for common needs such as defining fields, constants, adding base or parent classes, remapping methods, and marking modules in %INC. It also offers convenience pragmas like -strict and -as_base and emits debug traces when DEBUG_MOP4IMPORT is set. If you need features beyond its built in dispatching, you can subclass and override dispatch_import to implement tag lists or other advanced Exporter behavior.

Dist::Zilla::Plugin::Repository automatically detects your project’s version-control checkout and writes the repository information into the distribution metadata so CPAN and other tools can link back to your source. You enable it by adding [Repository] to dist.ini and it handles common systems such as git, svn, cvs, darcs, bzr and hg while letting you override detection with an explicit repository URL or choose which git remote to use. It maps repository and web URLs into CPAN Meta fields and supports modern metadata practices, though the old github_http option is deprecated and using the MetaJSON plugin is recommended if you need both clone and web URLs. The most recent release broadened support for marking repositories with issue and web endpoints so hosting platforms like GitHub, GitLab and Bitbucket are represented correctly. The implementation is largely based on Module::Install::Repository, so it should feel familiar to users of that tool.

Math::GMPf is a Perl binding to the GNU MP (GMP) library's mpf floating‑point facility that gives you arbitrary precision "bigfloat" arithmetic from Perl. It wraps GMP's mpf API as Perl functions and methods for creating and assigning high‑precision floats, controlling precision, performing arithmetic and comparisons, converting to strings and native numeric types, formatted I/O, and generating random floats, and it overloads common numeric operators so Math::GMPf objects behave like native numbers. The module requires the GMP C library to be installed and returns blessed objects that are automatically cleaned up when they go out of scope, with alternative nobless functions if you want manual memory control. Use Math::GMPf when you need accurate floating point calculations beyond built-in doubles or when you want direct access to GMP functionality from Perl. Note that incorrect argument types can cause interpreter crashes, so follow the documented argument conventions and consult the GMP manual and the module test suite for examples.

Apache2::API is a developer-friendly Perl framework that sits on top of Apache/mod_perl2 and makes the server API much easier to use. It wraps request, response and server objects and provides ready-made helpers for JSON encoding and decoding, URL and UTF-8 handling, base64, UUID generation, htpasswd-style password hashing, logging and localized messages, plus convenient reply and bailout methods that format HTTP and JSON responses and errors for you. The module also manages handler registration, supports Server-Sent Events replies and optional response compression based on client capabilities and a configurable threshold. It exports Apache and APR constants for convenience and is designed to be extended, for example to provide custom gettext localization. If you are building mod_perl handlers or embedding Perl in Apache this module will save a lot of boilerplate and make common tasks straightforward, but it is only relevant in an Apache/mod_perl environment.

Git::Server is a drop-in replacement for a standard Git server that adds far more flexible server-side hooks, fine-grained access control and deployment tooling so you can enforce who can push what and trigger automated actions on every push or pull. It installs alongside SSH using an authorized_keys command and provides features like ACLs for writers, forcers and file-level push restrictions, IP and author-email whitelists, customizable pre/post hooks, webhook notifications, a git-client wrapper and a git-deploy helper for instant or background deployments. The module also supports proxy syncing to external remotes, detailed logging and safer defaults for bare repositories, and it includes helpers to verify SSH keys and client behavior. Recent releases improved the proxy functionality to allow multiple remote targets and syncing to empty repos, beefed up git-verify and git-deploy key handling and options, tightened a few security behaviors and added nicer diagnostics such as showing which public key connected; the project is actively maintained on GitHub with ongoing enhancements and bug fixes.

Perl::Critic::Policy::Security::RandBytesFromHash is a Perl::Critic policy that scans your code for the old and unsafe habit of generating "random" bytes by hashing predictable values such as rand, time, process id, reference addresses or internal counters and warns when it finds patterns like md5(rand() . time() . $$). It helps developers catch this subtle security footgun and points them toward proper sources of randomness such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. You enable it in your perlcriticrc and adjust severity as needed. Be aware it will conservatively flag any hash or join that includes insecure inputs and can sometimes report the same construct more than once. This module requires Perl 5.24 or newer.

MARC::Leader::L10N is a lightweight localization helper for projects that work with MARC leader labels and need translated text. You request a language handle with get_handle using an ISO 639-1 code or let it pick the locale default and then call maketext with a key to get the localized string. If a requested language is not available get_handle returns undef. The module builds on Locale::Maketext and is intended for library or metadata tools that want simple, consistent translations of leader-related labels. It is BSD 2-Clause licensed, available on GitHub, and this 0.01 release is the initial public version.

RT::Client::REST is a Perl library that lets your application talk to a Request Tracker (RT) server using its REST API, effectively converting the old command-line "rt" tool into an object you can script against. You can authenticate, fetch, create and edit objects like tickets, users and queues, post comments and correspondence, attach files, search and sort results, inspect transactions and links, merge or link tickets, and take or steal ownership, all while errors are delivered as catchable exceptions so you can handle them with Try::Tiny or eval. The API mirrors the original rt tool so simple tasks are quick to script and there are also more object-oriented companion classes such as RT::Client::REST::Ticket and RT::Client::REST::User for nicer OO usage. Note that show() and edit() operate on a single object at a time and the module currently does not retrieve RT forms, and recent maintenance releases such as 0.73 focus on bug fixes including correcting a get_links URL bug and other small namespace and typo fixes. If you need to automate or integrate RT operations from Perl programs this module is a practical, well maintained choice.

Control::CLI::Extreme is a Perl module for automating command-line interaction with a wide range of Extreme Networks (and ex‑Avaya/ex‑Nortel) devices over Telnet, SSH or serial consoles, providing a consistent scripting interface that handles varied prompts, login sequences, paging and confirmation prompts so you can run show and configuration commands reliably across different models. It subclasses Control::CLI and adds device-aware conveniences such as automatic device discovery and prompt setting, optional return-of-result mode for config commands, efficient return-of-output for show commands, non‑blocking polling to drive many devices in parallel without threads, and helpers for console wake sequences and serial baud changes. The module supports many families including ExtremeXOS, PassportERS, BaystackERS, SLX, ISW, VSP, WLAN and others, exposes device attributes like model, sysname and ports for conditional scripting, and works with SSH password or publickey authentication. Recent updates add OneOS support and a serial_number attribute, fix documentation and Perl warning issues, and otherwise refine prompt and error detection across newer hardware and firmware. If you need to automate CLI workflows across mixed Extreme gear and prefer a single, device-aware API for Telnet, SSH and serial access, this module is directly relevant.

Control::CLI is a pure-Perl toolkit that gives you a single, consistent API to drive command‑line interfaces over Telnet, SSH or serial ports and to capture their output. It wraps Net::Telnet, Net::SSH2 and Device::SerialPort or Win32::SerialPort so you can connect, authenticate, send commands, wait for prompts and log or hex-dump traffic without changing your code for each transport. The module supports terminal type and window size negotiation, SSH publickey and password authentication, IPv6 when IO::Socket::IP is available, and serial‑port features like baud, parity and on‑the‑fly baud changes. It includes a non‑blocking poll framework to manage many hosts from a single thread and helpers for parallel connect/login/cmd workflows, while also offering fine control of timeouts, prompt matching, newline translation and logging. Note that some transports require their underlying CPAN modules to be installed and that Net::SSH2 only implements SSHv2 and has portions of the auth flow that are not fully non‑blocking, which can affect very large parallel SSH batches. Overall this module is ideal for network engineers and sysadmins who need portable, scriptable automation of routers, switches and appliances across Telnet, SSH and serial links.

OpenGL::Modern is a comprehensive Perl binding to the OpenGL API (covering legacy 1.x up through modern 4.6) built on top of GLEW and generated from glew.h and the Khronos registry so the interface stays aligned with upstream changes. It exposes the full set of core and extension functions with granular export tags, POGL-like convenience variants for pointer and array arguments, and development helpers such as glpSetAutoCheckErrors to automatically call glGetError during debugging. The module includes compatibility shims so OpenGL::Image can work without loading the legacy OpenGL.pm and supports both Config and ExtUtils::Depends style builds. Recent releases fixed a long-standing crash by making glewInit verify there is an active GL context and return an error instead of segfaulting when none exists and added a glewHasContext() XS function to check context state. If you want direct, up-to-date OpenGL and extension access from Perl for graphics or GPGPU work this module provides a production-ready, well maintained solution.

Meetup::API is a lightweight Perl wrapper for the Meetup.com REST API that makes it easy to fetch groups, events and related data from Perl code using simple method calls like group_events->get. It defaults to API version v3 but lets you override the version when constructing the object. To use it you register with Meetup, obtain an API key and place a JSON file named meetup.credentials in your home directory with an applicationKey field so the module can authenticate. The distribution depends on common JSON modules (JSON::PP/JSON::XS) and is maintained on GitHub; a recent release fixed compatibility with Net::CalDAVTalk 0.14 to avoid breakage.

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.