CPANscan

URI is a general purpose Perl class for creating, parsing and manipulating Uniform Resource Identifiers according to the RFCs, letting you build absolute or relative URIs, combine them with base URIs, and convert them to and from plain strings or Unicode IRIs. It exposes simple accessors to get and set components like scheme, authority, host, port, path, query and fragment, plus convenience helpers to canonicalize and compare URIs, turn relative URIs into absolute ones and vice versa, and work with query data using form- and keyword-oriented methods. The module dispatches to scheme-specific subclasses when available so you get extra methods for common schemes such as http, https, ftp, file, mailto, ldap, ws and many others, and it knows about default ports, IDNA host handling and percent-encoding rules. It is stable and widely used but the author notes a couple of quirks to watch for such as odd behavior when passing regexp variables like $1 directly to accessors and the way non-ASCII bytes are percent-encoded depending on a string s internal UTF8 flag. If you need a robust, RFC-aware URI toolkit in Perl for building, normalizing or dissecting URIs this module is a solid choice.

Lemonldap::Portal::Standard is a Perl module that implements the authentication workflow for the Lemonldap single sign on system and provides a ready-made LDAP-backed form login handler. It drives the whole login cycle from request and timeout handling to form validation, optional user ID formatting, LDAP connect/bind/search, session construction and final credential validation, and each step can be overridden with custom callbacks. You instantiate it with new and call process with CGI-like parameters and LDAP settings, and it supports anonymous binds by leaving the manager credentials undefined. Helper methods return error codes and messages, session data and redirection URLs and the module uses a specific nonfatal code for an initial empty form so you can distinguish that case. The component is GPLv2 licensed and is useful when you need an extensible, production-ready LDAP authentication layer for a web SSO setup.

Finance::Bank::Bankwest is a Perl library for programmatically logging into Bankwest Online Banking with a Personal Access Number and access code so you can list accounts, read balances and fetch transaction histories via a returned Session object. It exposes account and transaction objects with useful helpers so scripts can report balances and iterate transactions easily. This is an unofficial third‑party client so you should audit the code and check Bankwest’s terms before using it in production because Bankwest does not support this module. The project is maintained on GitHub and recent updates improved robustness by skipping post‑login service‑message pages automatically and by tolerating missing transaction codes in some responses. The module is free software licensed under the same terms as Perl.

Crypt::DSA is a pure-Perl implementation of the Digital Signature Algorithm that provides key generation, signing and signature verification with the heavy numeric work delegated to Math::Pari. You create a Crypt::DSA object, generate a keypair (you must pick the p size, with q and g fixed at 160 bits), sign either a message or an explicit 20-byte digest (the module will SHA1 the message for you) and verify signatures using the public key; the API is intentionally similar to Crypt::RSA and returns Crypt::DSA::Key and Crypt::DSA::Signature objects. Important security notes: DSA is no longer recommended for new systems and this module is marked deprecated in favor of alternatives such as Crypt-DSA-GMP, so use it only to verify legacy signatures. Recent releases fixed critical issues including a nonce reuse flaw (CVE-2026-12205) that could allow private-key recovery if the same key was used to sign multiple messages with affected versions, so any keys used to sign more than once with those versions should be considered compromised.

Apertur::SDK is the official Perl client for the Apertur API that simplifies common tasks like creating upload sessions, uploading images (including optional encrypted uploads), long polling for processing results, verifying webhook signatures, and performing CRUD on destinations, API keys, webhooks and encryption keys. It supports both API key and OAuth token authentication and will auto-select the sandbox environment when given a test key prefix, so you can develop safely. Errors are thrown as typed exception objects to make handling authentication, validation and rate limit problems straightforward. Encryption features are provided but require optional crypto modules which are loaded only when needed. If you build Perl applications that interact with Apertur for image ingestion or delivery workflows this SDK gives a convenient, ready-made interface.

Jacode is a compact Perl library for detecting and converting Japanese text between common encodings such as JIS, EUC, Shift_JIS and UTF-8, with support for newer JIS X 0213 planes and utilities to inspect escape sequences and encoding boundaries. It exposes simple routines like convert to transcode a scalar in place, getcode to guess the encoding of a buffer, and helpers to examine JIS in/out escape states, and on modern Perls it can act as a wrapper around Encode when asked to handle other encodings. The module is written to be broadly compatible with older Perl releases while staying usable on current Perls and includes extensive tests and documentation. A recent maintenance update simplified the UTF-8 source-file self-check so it no longer uses Perl‑5‑only syntax and added a small safeguard to suppress a spurious apostrophe-package-separator warning on very new Perls, improving backward and forward compatibility.

Data::Identifier provides a single, format‑independent object for working with many kinds of identifiers such as UUIDs, OIDs, URIs, Wikidata and FactGrid IDs, GTIN, IBAN, BIC, DOI and others, letting you keep both the raw value and its type while offering normalization and basic deduplication. It can create identifiers from strings or from other objects, produce canonical forms (UUID, OID, URI or a combined ISE form), generate high quality random identifiers from a variety of sources, compare and sort identifiers, and convert them into related objects for use with URI and tagging libraries or file and datecode modules. The module supports type-level options like validation patterns, namespaces and generators, returns user-friendly display names or permanent tagnames for UI use, and lets you register frequently used identifiers to improve performance. Validation and deduplication aim for practicality and speed so they may not catch every invalid value and deduplication is not guaranteed to merge all equal identifiers. Some features are marked experimental and you can disable OID support to gain speed if you do not need it.

Mac::Pasteboard provides a Perl interface to macOS pasteboards and the system clipboard, letting scripts and programs read and write clipboard data. It offers simple exported helpers pbpaste and pbcopy for plain text and a full object-oriented API to work with named pasteboards, individual pasteboard items and Uniform Type Identifier flavors so you can store or retrieve different data types and inspect flavor flags and tags. The module includes optional encoding handling for several text UTIs, taint-aware behavior, error/status reporting and a set of constants for common pasteboard errors and flags. Note that it requires macOS 10.3 or later, currently only accesses the first item on multi-item pasteboards, does not support promised data, and some encoding behavior may be unreliable on older macOS or Perl versions. If you need programmatic clipboard control on macOS from Perl, this module supplies a practical and featureful toolkit.

HTML::TableContentParser is a small utility for pulling the contents of HTML tables into simple Perl data structures so you can work with rows, cells and headers without writing a full DOM scraper. You create a parser and call parse($html) to get an array reference of tables found in document order, and each table is returned as a hashref containing attributes plus useful keys like caption, headers and rows where each row lists its cells and any th/header entries with their text in a data field. There is a classic option to preserve older behavior for <th> handling if you need backward compatibility. The module intentionally ignores rowspan and colspan and nested tables are reported separately rather than being linked into their parent cell, but recent maintenance releases fixed nested-table truncation and improved row-header (<th>) support along with metadata and test updates.

Games::Sudoku::General is a Perl module for solving and generating Sudoku-style puzzles with flexible rules and layouts. Instead of assuming a square grid it lets you define arbitrary topologies so you can handle standard 9x9 Sudoku, Latin squares, Samurai (quincunx), cube variants, odd/even or high/low constraints, and many custom designs, and you can define custom symbol sets and multi-character symbols. It can both generate puzzles with controllable difficulty and constraints and solve given puzzles while also producing a human-readable trace of the solving steps so you can see which logical rules produced each placement. Generation is heuristic and not guaranteed to succeed and very exotic constraints called X, Y, and W are not implemented as dedicated rules though the solver will fall back to backtracking when needed. Clipboard copy and paste require the Clipboard module. If you need a general, extensible Sudoku engine in Perl that explains its reasoning and supports nonstandard puzzles, this module is a good fit.

Game::Life::Faster is a Perl implementation of Conway's Game of Life that focuses on speed and low memory use for large, mostly empty grids. It exposes a Game::Life-like API so you can create rectangular grids, tweak birth and survival rules, place or toggle patterns, run iterations, and get text or region-limited representations of the grid. Under the hood it uses a hash-based grid and change bookkeeping to avoid autovivifying unused cells and to limit processing to active areas, and recent releases added efficient used/active-region queries and an executable script with load and pause options. If you need a faster, more memory-efficient Game of Life engine in Perl for sparse simulations this module is a good fit, while noting a few small incompatibilities with Game::Life such as scalar get_text_grid returning a single string and place_points ignoring undef values.

BATsh is a pure-Perl bilingual shell that lets you write and run files containing both Windows cmd.exe batch syntax and Unix sh/bash syntax in the same script, with the interpreter switching modes line by line and sharing variables via BATsh::Env. You can run script files, evaluate shell source strings, or use an interactive REPL, and the implementation supports common builtins, pipelines, I/O redirection, functions, control flow, batch parameters and many familiar cmd and sh features so most cross-platform scripting patterns work inside Perl without launching an external shell. Only non-built-in programs are executed via the host operating system so commands like FINDSTR, SORT or other platform-specific utilities require the corresponding executable to be present. The SH side omits arrays, brace expansion, tilde expansion and several advanced shell features, and the CMD side has a few unimplemented FOR /F variants and some subtle differences in block expansion and scope because parenthesised groups do not create isolated subshells. BATsh is suitable when you need a single, portable interpreter that mixes Windows and Unix shell idioms directly in Perl and are willing to accept the noted limitations for the convenience of a unified, pure-Perl solution.

Plack::Middleware::Security::Simple is a lightweight Plack middleware that lets PSGI applications block obvious attack patterns by matching request environment fields against simple rules. Rules can be provided as an array reference of key/regex pairs, a Hash::Match object, or a custom subroutine that inspects the Plack environment, so you can block things like bad user agents or requests for CGI and PHP paths. When a rule matches a default handler logs the event to psgix.logger and returns a configurable HTTP status (400 by default), and you can replace the handler to customize the response or raise HTTP exceptions. This module is useful when you want an easy in-application filter for common probes and malicious requests, and it requires Perl 5.14 or newer; for more comprehensive filtering you may prefer a reverse proxy solution such as modsecurity.

DBIx::QuickORM is a Perl DSL for building modular, reusable object-relational mappings that lets you declare ORMs, servers, databases, schemas, tables, columns, links and row classes in code instead of plumbing DBI calls by hand. It supports composing pieces across ORMs, grouping connection settings into servers, choosing SQL dialects and DBI drivers, attaching plugins, and defining types, defaults, indexes and constraints so you can both generate schema SQL and shape how rows are inflated into objects. The autofill tool can inspect an existing database and automatically build schema and row classes with hooks to customize naming, skipping, and type mapping. If you need a programmable, repeatable way to map multiple databases or deployments into consistent Perl row classes and queries, DBIx::QuickORM gives a concise, extensible framework to do that.

Test::Simple is a tiny, no-frills testing toolkit for Perl that lets you write TAP-compatible tests with a single primitive. You declare how many tests you plan to run then use ok to record pass or fail and output lines like "ok 1" or "not ok 2", and the module produces sensible exit codes so harnesses and CI can tell success from failure. It is intentionally minimal to get you started quickly and is fully forward compatible with Test::More when you need richer assertions and diagnostics. Test::Simple is mature and well maintained across many Perl versions, and recent work has modernized its internals to use the newer Test2 infrastructure and cleaned up packaging and test reporting so diagnostics and line numbers are more accurate.

DBIx::QuickDB is a small utility for quickly creating disposable database servers for testing and development, letting you spin up PostgreSQL, MySQL/MariaDB, SQLite and optional DuckDB instances on demand. You can declare named databases at compile time that provide connection constants or build them programmatically at runtime, and each instance supports options like autostart/autostop, bootstrap, cleanup (which will delete the data dir so do not use it on production data), loading SQL schemas, driver selection or fallbacks, and global caching of built instances. It is designed for test suites and CI workflows where you need isolated, short-lived servers or cloned database copies, and it includes convenience features like a driver viability checker, pool and clone support, and environment knobs such as QDB_TMPDIR and DB_VERBOSE. Recent releases focus on robust teardown and resource handling including a fast_destroy path and improved watcher shutdowns to avoid leaked resources and stalled shutdowns. The source is on GitHub if you want to inspect drivers or contribute.

Audio::Scan is a fast C-based Perl module for extracting metadata and tag information from most common audio formats including MP3, MP4/M4A, Ogg Vorbis, FLAC, ASF/WMA, WAV, AIFF, Musepack, Monkey's Audio, WavPack and several others. It exposes simple routines to scan a file or filehandle for both technical info and user tags or to get just tags or just file info. You can request an audio-only MD5 to detect identical audio despite differing tags and you can locate byte offsets for seeking or produce rewritten headers for MP4 and Ogg/FLAC to build seeked streams. Embedded artwork can be skipped to save memory by setting an environment flag though some formats still allocate memory for images and FLAC files will use an internal MD5 when present. The module returns normalized, UTF-8 tag data and rich format-specific info such as bitrates, durations, offsets and codec details, making it a practical choice for media servers, taggers and batch metadata tools.

Developer::Dashboard is a Perl-based local "home" for development that unifies a lightweight browser UI, a single CLI entrypoint and a prompt status layer so links, notes, helpers, and status checks live in one place instead of scattered scripts and tabs. It runs a local web app by default on port 7890, ships a "dashboard" command with built-in helpers for opening files, querying JSON/YAML/TOML/properties, and wrapping Docker Compose, and it uses background "collectors" to prepare cached state that feeds compact indicators for the web chrome and shell prompt. The runtime is layered so per-project ./.developer-dashboard trees override a secure home runtime under ~/.developer-dashboard, and the system stages private helper assets and supports custom CLI hooks plus an installable "skills" plugin system for project-specific pages, collectors and commands. It handles lifecycle tasks like starting and supervising web and collector processes, can generate a self-signed local SSL cert, and targets mixed-language teams by keeping workflows, path aliases, file shortcuts and Docker overlays consistent across repositories.

Dist::Zilla::PluginBundle::Author::DBOOK is a ready-made collection of Dist::Zilla plugins that mirrors Dan Book's own build-and-release setup, so you can automate the routine tasks of preparing a CPAN distribution. It wires together metadata and README generation, prereq harvesting from cpanfile or prereqs json/yml, git-aware file gathering, committing, tagging and pushing, version bumping, test and pod checks, and copy-out of release artifacts like META.json, LICENSE and Makefile.PL. You can tweak behavior with a few dist.ini options such as github_user, installer and pod_tests, and the bundle assumes a git repo with a Changes file and a declared set of prereqs; it also supports a FAKE_RELEASE mode to exercise the release steps without uploading.

mb.pm is a lightweight "modulino" that lets you run Perl scripts written in a variety of legacy multibyte encodings by transparently transpiling MBCS literals and regexes into octet-oriented Perl that still behaves sensibly at the codepoint level. You run your script with perl mb.pm [options] script.pl and it produces a temporary transpiled file while adding multibyte anchoring, escaping problematic multibyte sequences, rewriting character classes, and offering an mb:: namespace of codepoint-aware helpers such as mb::length, mb::substr, mb::tr and mb::chop so you can choose byte or codepoint semantics where needed. It supports Big5, Big5-HKSCS, EUC-JP, GB18030, GBK, Shift_JIS/CP932, UHC, UTF-8 and WTF-8, works on common OSes and recent Perl versions, and avoids using Perl's UTF8 flag to reduce mojibake. Because it is a source filter it produces an extra .oo.* file and you invoke it via the mb.pm wrapper rather than changing the interpreter, and there are known limitations such as some regex and Unicode features not being supported (named codepoints, Unicode properties, some look-behind and cloistering), a Windows chdir edge case, and a few behavior differences inherited from the design choices. Use mb.pm if you need JPerl-like convenience for maintaining or running MBCS-encoded Perl scripts without converting them to UTF‑8 or rebuilding Perl itself.

Protobuf is a placeholder CPAN module that simply reserves the Protobuf namespace for future Perl bindings to Google's Protocol Buffers. It does not provide any runtime functionality or helpers and exists only to claim the name so later work can be published under Protobuf. Protocol Buffers are Google's compact, language-neutral format for serializing structured data, so if you need a working Perl implementation today this module is not the implementation you want, but it signals that official bindings may appear here in the future. The package is published under the Apache License 2.0 and attributed to C.J. Collier and contributors.

DesktopWorkspace is a concise specification for declaring what should be opened to set up a desktop workspace — applications, files, directories and browser URLs — so you can create reusable workspace presets (for example coding, writing or project-specific setups) under a DesktopWorkspace:: namespace. A specification is a DefHash containing an items array plus flags such as new_browser_window and kde_activity and each item must be one of url, file, dir or app_path with optional hints like firefox_container or per-item new_browser_window. It is aimed at automating or documenting which windows and browser tabs to open rather than performing the launches itself and currently a single spec only targets one KDE activity. The series is still 1.x/unstable with 2.x planned as the stable API and this release (1.0.0) is an early release.

Linux::Event provides a compact, Linux-native readiness event loop for Perl that uses kernel primitives like epoll, timerfd, signalfd, eventfd, and pidfd to handle timers, signals, wakeups, and child-process exit notifications. It intentionally stays at the loop-and-primitives layer, exposing a simple Loop object with a built-in epoll backend by default and relying on companion modules for higher-level socket, stream, and process helpers. The recent release simplifies the distribution into a single readiness loop, removes the experimental io_uring/proactor machinery and the older operation API, and standardizes the backend abstraction to make the API smaller and easier to use. Choose this module if you need a lightweight, native event loop on Linux for building asynchronous I/O or process integrations in Perl and prefer to assemble higher-level behavior from focused companion modules.

ioqwerty is a tiny placeholder module on CPAN that exists solely to reserve the distribution name "ioqwerty". It provides no runtime features and simply holds the namespace for the author. The package is released under the MIT license and the author lists contact as ping@ioqwerty.com. Installers should not expect functionality from this module; it is useful only for claiming the name or preventing others from taking it.

Dist::Setup is the internal library that powers the perl_dist_setup command and provides a ready-made framework for creating and maintaining Perl distribution skeletons. It generates Makefile targets and CI configuration, wires up testing helpers such as Test::CPANfile, and adds tooling for style checks, spellchecking, perltidy, perlcritic, packaging and uploading so authors can focus on code instead of build plumbing. The module is mainly useful to module authors and to the perl_dist_setup tool rather than for direct use in applications, and full user-facing documentation lives on the perl_dist_setup page. Recent updates improved GitHub CI dependency installation to avoid dependency loops when installing suggested modules and added perltidy processing of test (.pm) files, along with support for newer Perl releases.

I don't see any module POD text to summarize; what I received was only a small JSON mapping that references App::PTP::Cheat_Sheet and a script named ptp but no actual documentation content. I can't create the concise descriptive paragraph you asked for without the module's POD or a link to its CPAN page or README, so please paste the POD or provide the module name or URL and I will produce a clear, one‑paragraph summary tailored to a technically literate audience.

Params::Validate::Strict is a Perl parameter validation library that checks and coerces input against a declarative schema so your code gets well-formed, typed data back. You describe each parameter with types like string, integer, number, arrayref, hashref, coderef or object and add constraints such as min/max, regexes, enums, optional/default values, transforms, callbacks and nested schemas, and the module supports custom reusable types, positional arguments, cross-field validations and relationship rules for common patterns like mutual exclusivity or conditional requirements. It returns a new hash or positional array with coerced values and is useful for input sanitization, building simple WAF rules, generating black‑box tests or improving API documentation. The recent 0.34 release added a stringref type and more robust integer handling including acceptance of valid scientific notation while rejecting infinities and NaNs and fixed a few edge-case bugs around stringref transforms and optional callbacks. If you need a feature-rich, declarative way to validate and normalize incoming parameters in Perl, this module is likely a good fit.

Dist::Zilla::PluginBundle::Codeberg makes it easy to publish and maintain Perl distributions on Codeberg by wiring in two Dist::Zilla plugins that set up Codeberg metadata and updates for your release. It reads your Codeberg repo from a git remote or an explicit repo setting and can pull credentials from git config or a Config::Identity file; you must create a personal access token with the "api" scope. The bundle sets meta fields such as the bug tracker, homepage and wiki and offers options to prefer the dist meta, MetaCPAN or p3rl links, to follow forked repositories, and to choose the git remote name. If you already use Dist::Zilla and host code on Codeberg this bundle automates the bookkeeping and release integration. Note that the 2.0 release is a major update that adapts a GitLab-based bundle for Codeberg and includes API changes and bug fixes.

Mojolicious::Plugin::Fondation is a plugin loader for Mojolicious that helps you build modular web applications from reusable bricks by loading plugins recursively according to declared dependencies and merging their configurations with a clear priority: direct overrides, then application config, then plugin defaults. It automatically shares plugin resources like templates and public files with the application, runs configurable post-load actions to register templates, controllers and static assets, and provides a deferred fondation_finalyze hook so plugins can complete initialization after everything else is loaded. The plugin also supplies convenient helpers and a zone system for assembling HTML or JavaScript fragments from multiple plugins into layout zones. To fully participate in finalization a plugin must return $self from its register method. This initial release introduces hierarchical plugin loading, resource sharing, and a predictable configuration cascade to make composing Mojolicious apps from many small plugins easier.

Type::Guess examines a list of scalar values and infers the most appropriate data type (Str, Int, Num or DateTime when a date role is enabled) while tracking field width, precision and sign and producing an sprintf-style format string you can use to print the original values consistently. The object stringifies to that format and can be invoked like a function to format individual values, which makes it handy in formatting pipelines. Pluggable roles add features such as DateTime parsing, a dependency-free DateTime::Naive detector, Unicode-aware display widths, Type::Tiny integration, and SQL column type generation for dialects like SQLite and Postgres. You can adjust global settings such as tolerance for outliers and whether to skip empty strings, override the generated format, or export the detected attributes as a hash for reuse. Use Type::Guess when you need quick, automated type detection for display formatting or for helping generate sensible database column definitions.