CPANscan

EV::Etcd is a high-performance asynchronous client for etcd v3, leveraging native gRPC and the EV/libev event loop for efficient communication. It allows developers to interact with etcd's key-value store using non-blocking operations, enabling features such as asynchronous key-value storage (put/get), watching for changes, and managing leases and distributed locks. The module supports comprehensive authentication and authorization mechanisms, making it suitable for secure applications. Additionally, it provides cluster management capabilities, leader election support, and maintenance operations, all designed to facilitate robust and scalable distributed systems. With its straightforward API, EV::Etcd simplifies the integration of etcd into Perl applications, enhancing their performance and responsiveness.

The Time::OlsonTZ::Data Perl module provides a comprehensive interface to the Olson timezone database, encapsulating essential timezone data and binary tzfiles for various regions. It allows users to access key functionalities such as retrieving the current version of the database, obtaining canonical and link timezone names, and understanding the relationships between timezones and countries. With functions like olson_tzfile, users can easily obtain the pathname of the binary tzfile for a specified timezone, ensuring accurate and up-to-date timezone information. This module is designed to be regularly updated to reflect changes in timezone rules and data, making it a vital tool for applications that require precise timezone management.

The Sys::Async::Virt module provides an asynchronous interface for interacting with LibVirt services through its remote protocol, enabling Perl clients to manage virtualized environments effectively. Built on the LibVirt API, this module allows users to connect to hypervisors, list and manage domains, and handle various virtualization tasks using an object-oriented approach. It supports asynchronous operations through the Future::AsyncAwait framework, allowing for non-blocking calls and efficient handling of remote procedure calls (RPCs). With features like event subscriptions for domain and network changes, as well as comprehensive methods for querying and manipulating virtual resources, Sys::Async::Virt is an essential tool for developers working with virtualization in Perl.

The `Protocol::Sys::Virt` Perl module provides an abstract implementation of the LibVirt protocol, enabling the development of client and server components for managing virtualization technologies. Unlike its predecessor, `Sys::Virt`, this module offers a truly asynchronous interface, addressing the limitations of blocking API calls inherent in the original design. This is particularly beneficial for developers looking to implement non-blocking operations in their applications. The latest version, v12.1.0, continues to enhance compatibility with the LibVirt project, ensuring that users can leverage the latest features and improvements from the underlying protocol.

Date::Manip is a comprehensive Perl module designed for effortless date and time manipulation, catering to a wide range of operations such as comparing dates, calculating time intervals, and parsing international date formats. It supports the Gregorian calendar and accounts for daylight saving time, making it versatile for various applications. Users can input dates in numerous formats, extract specific information, convert between time zones, and manage recurring events with ease. With both functional and object-oriented interfaces available, Date::Manip is particularly recommended for its object-oriented approach, which unlocks the full potential of its extensive capabilities. Whether you need to perform simple calculations or complex date manipulations, Date::Manip provides a robust solution for all your date-related programming needs.

The `String::Redactable` Perl module provides a mechanism for handling sensitive strings, such as passwords, by automatically redacting them to prevent accidental exposure in logs or outputs. When a `String::Redactable` object is created with sensitive text, it displays as a placeholder string (e.g., "<redacted string>") when used normally, while the actual content can only be accessed through the `to_str_unsafe` method. This design helps mitigate the risk of unintentionally revealing sensitive information, as the original string is XOR-encrypted with a transient key that is not stored with the object. Additionally, the module includes features to resist serialization, ensuring that sensitive data remains protected even when serialized. Overall, `String::Redactable` is a useful tool for developers looking to enhance the security of sensitive string handling in their applications.

MooX::Cmd is a Perl module designed to simplify the creation of command-line interface (CLI) applications using the Moo object system. It allows developers to organize commands and subcommands in a hierarchical structure, mirroring the package structure of the application. Each command is defined as a class with an `execute` method that receives parameters for the command instance, the arguments passed to it, and the chain of commands leading to it. This structure enables the easy handling of complex command trees, where only the most specific command's `execute` method is invoked, while also providing access to attributes and options defined at higher levels in the command hierarchy. With MooX::Cmd, developers can efficiently build modular and organized CLI applications that are easy to maintain and extend.

Container::Builder is a Perl module designed for creating TAR archives that can be imported into containerization tools like Podman or Docker, specifically tailored for building lightweight containers based on Debian packages. It provides a range of methods that mimic Dockerfile functionalities, allowing users to create directories, add files, and manage users and groups within the container environment. With the ability to specify a Debian mirror, add Debian packages, and set environment variables, Container::Builder streamlines the process of crafting custom container images. Although still in early development stages and not yet production-ready, it offers a flexible framework for developers looking to experiment with containerization using Perl.

Aion::Emitter is a Perl module that implements the Event Dispatcher pattern, allowing for efficient event handling and listener management within applications. By defining events through event object classes, it enables the registration of listeners that respond to specific events using the "#@listen" annotation. The module provides an `emit` method to trigger events, invoking all associated listeners, and allows for targeted event emissions through an optional key parameter, facilitating more granular control over event handling. This makes Aion::Emitter particularly useful for applications that require dynamic interaction between components, such as in GUI applications or complex systems where events need to be dispatched to specific listeners based on context.

DBIx::Class::Async is an experimental Perl module designed to provide a non-blocking, multi-worker asynchronous interface for the popular DBIx::Class ORM, enabling developers to perform database operations without freezing the main application loop. By utilizing a worker-pool architecture, it allows multiple database queries to be executed in parallel, significantly improving responsiveness in applications that require heavy database interactions. The module integrates seamlessly with various event loops, such as IO::Async, and supports modern asynchronous programming patterns, including Futures and async/await syntax. With features like automatic serialization of results, error handling, and optional caching, DBIx::Class::Async is ideal for building responsive applications that demand efficient database access without compromising performance.

The `Unicode::UTF8` Perl module provides essential functions for encoding and decoding UTF-8, adhering to Unicode standards. It allows developers to easily convert between octet strings and character strings using the `decode_utf8` and `encode_utf8` functions, while also offering customizable error handling through optional fallback mechanisms. Additionally, the module includes a `valid_utf8` function to check the integrity of UTF-8 sequences. Recent updates have significantly improved performance, with a notable rewrite of the UTF-8 validator that enhances decoding speed by up to 10 times compared to previous implementations. This makes `Unicode::UTF8` a powerful tool for handling UTF-8 data efficiently in Perl applications.

HTTP::Handy is a lightweight, single-file HTTP/1.0 server designed for Perl 5.5.3 and later, ideal for personal use, local tools, and rapid development. It implements a subset of the PSGI specification, allowing developers to create simple web applications with minimal setup—just copy the file into your project directory. The server supports basic GET and POST methods, serves static files with MIME type detection, and includes utility functions for URL decoding and query parsing. Notably, it features an access log in LTSV format and allows configuration of the maximum POST body size. With no external dependencies, HTTP::Handy is perfect for quick prototyping and local development environments. The first release on CPAN marks its availability for broader use, emphasizing its simplicity and portability.

App::Git::Autofixup is a Perl module designed to facilitate the creation of fixup commits for topic branches in Git, streamlining the process of managing changes. This module acts as a wrapper around the git-autofixup application, allowing users to generate fixup commits based on staged hunks in the index. A notable recent enhancement in version 0.005000 allows users to specify file paths on the command line, limiting the fixup commits to those files only, improving usability for targeted changes. With ongoing improvements and bug fixes, App::Git::Autofixup continues to evolve, making it a valuable tool for developers looking to maintain clean commit histories in their Git workflows.

PDL, or Perl Data Language, is a powerful Perl extension designed for efficient scientific and bulk numeric data processing and visualization. It enhances Perl's capabilities by providing fully vectorized, multidimensional array handling, making it suitable for managing large datasets such as images and spectra. With its fast performance, often surpassing that of IDL and MATLAB, PDL allows users to perform complex mathematical operations and manipulations on N-dimensional arrays with ease. The module includes an interactive shell for learning and exploring its functions, along with extensive documentation and tutorials to support users from beginners to advanced levels.

Device::GPIB is a Perl extension designed to facilitate access to a wide range of GPIB (General Purpose Interface Bus) devices through various supported interfaces, including Prologix and LinuxGpib controllers. This module serves as a comprehensive wrapper for specific device modules, enabling users to send commands and queries to compatible instruments such as those from HP, Tektronix, and Advantest. With the ability to handle both GPIB and direct serial connections, Device::GPIB simplifies the interaction with laboratory equipment, making it easier to perform tasks like scanning the GPIB bus or executing device-specific commands. Notably, recent updates have expanded device support, including the addition of the HP5342A Microwave Frequency Counter and improvements to serial communication handling, ensuring robust performance across different platforms.

The `Linux::Event::Connect` module provides a nonblocking mechanism for establishing outbound TCP or Unix-domain socket connections within the `Linux::Event` framework. It allows developers to initiate a connect request with a specified host and port, or a Unix socket path, while managing the connection state through a dedicated request object. This module supports optional callbacks for successful connections and error handling, along with a timeout feature to prevent indefinite blocking. By utilizing this module, developers can efficiently handle socket connections in an event-driven manner, ensuring that their applications remain responsive while waiting for network operations to complete.

Linux::Event::Listen is a Perl module designed for creating and managing listening sockets within a Linux::Event loop, facilitating non-blocking network communication. It allows developers to specify a host and port (or a UNIX socket path) for the listener and provides a callback mechanism for handling accepted connections through the `on_accept` function. This module is intentionally lightweight, focusing solely on the acceptance of connections while leaving the management of per-connection watchers to the user. Recent updates include the addition of a canonical server example that integrates Linux::Event::Stream with a line codec, enhancing the module's usability for handling message framing in network applications.

OpenAPI::Modern is a Perl module designed to validate HTTP requests and responses against OpenAPI v3.0, v3.1, or v3.2 specifications, ensuring compliance with the defined API schema. It provides a robust framework for developers to create and maintain APIs by allowing them to validate incoming requests and outgoing responses against a specified OpenAPI document. The module supports various HTTP request and response types, including those from popular frameworks like Mojolicious, Plack, and Dancer2. Recent updates include support for the "defaultMapping" feature in the 3.2.0 discriminator object, enhancing its capability to handle complex API structures. With its comprehensive validation tools and adherence to the latest OpenAPI standards, OpenAPI::Modern streamlines API development and ensures consistent behavior across different environments.

The App::MARC::Validator module is a Perl tool designed for validating MARC (Machine-Readable Cataloging) records, ensuring that they conform to the standards and specifications required for bibliographic data. This module provides a command-line interface through the `marc-validator` script, allowing users to easily check the integrity and correctness of MARC records, which is essential for libraries and information systems that rely on accurate cataloging. By utilizing this validator, users can streamline their cataloging processes and maintain high-quality bibliographic data.

MARC::Validator is a Perl module designed to facilitate the validation of MARC (Machine-Readable Cataloging) records through a set of plugins. By utilizing the `plugins` method, users can retrieve a list of available validation plugins, which can be employed to check various fields within MARC records for compliance with specific standards. Recent updates in version 0.11 include the addition of a 'recommendation' flag for reporting, new plugins for validating the 045 and 300 fields, and enhancements to the processing of filters within plugins, making it a robust tool for librarians and archivists working with MARC data.

The Gherkin Perl module serves as a parser and compiler for the Gherkin language, which is integral to the Cucumber testing framework. This module allows developers to read and process Gherkin feature files, transforming them into structured messages that can be utilized in automated testing pipelines. By leveraging the official Gherkin grammar, it generates Abstract Syntax Trees (AST) and executable scenarios, facilitating seamless integration with other components of the Cucumber toolkit. Users can customize the output to include source text, AST, and pickles, while the module's methods enable the processing of multiple feature files efficiently. Overall, Gherkin enhances the capability of Perl applications to work with behavior-driven development (BDD) practices.

Linux::Event::Stream is a Perl module designed to facilitate buffered, backpressure-aware I/O operations for nonblocking file descriptors, making it particularly useful for applications that require efficient data handling, such as network servers or inter-process communication. It provides a flexible interface that supports both raw byte streaming and framed/message modes, allowing developers to receive data in arbitrary chunks or complete messages, respectively. The module incorporates features like write buffering, high/low watermark tracking for backpressure management, and graceful closing after draining buffered data. Recent updates have introduced built-in codecs for message framing, enhancing its usability for structured data communication. Overall, Linux::Event::Stream serves as a lightweight policy layer over file descriptors, streamlining asynchronous I/O operations while maintaining control over data flow.

The App::GUI::Harmonograph module is a Perl application that simulates the classic harmonograph drawing apparatus, allowing users to create intricate spiraling images using up to six pendula, including lateral and rotary movements. With an intuitive graphical user interface, users can manipulate various parameters such as frequency, amplitude, and damping to observe real-time previews of their drawings. The module supports multiple output formats, including PNG, JPEG, and SVG, and enables users to save their settings for future use. Enhanced features include the ability to oscillate pendula at non-integer frequencies, apply complex color patterns, and adjust visual settings for line thickness and dot density, making it a versatile tool for both artistic exploration and mathematical visualization.

Future::IO::Impl::Uring is a Perl module that provides an implementation of Future::IO using the IO::Uring interface, designed for asynchronous I/O operations in a Linux environment. With this module, developers can leverage the capabilities of IO::Uring to perform non-blocking I/O tasks efficiently, simply by loading the module alongside Future::IO. It requires a Linux kernel version of 6.7 or higher to operate effectively. Notably, in the recent version 0.009, the module has declared a dependency on the correct version of Future::IO, ensuring compatibility and stability for users. This module is particularly useful for applications that require high-performance I/O operations, making it a valuable addition to the Perl ecosystem.

App::Wikidata::Template::CS::CitaceMonografie is a Perl module designed as a base class for the command line tool `wd-citace-monografie`, which facilitates the generation of bibliographic citations in the Czech language using data from Wikidata. The module provides a straightforward interface with a constructor for creating an instance and a `run` method that executes the citation generation process, returning an exit code to indicate success or failure. Recent updates in version 0.06 include the addition of tests for real-world scenarios from Wikidata, specifically addressing translators defined by properties P655 and P2093, as well as improvements to the callback functionality, enhancing the module's reliability and usability for developers working with bibliographic data.

Regexp::Compare is a Perl module designed for comparing regular expressions to determine their partial ordering, specifically to check if all strings matched by one regex are also matched by another. This functionality is particularly useful for optimizing blacklists implemented through regular expressions. The module provides the `is_less_or_equal` function, which takes two regex strings as arguments and returns true if the first regex is a subset of the second. Notably, recent updates have improved compatibility with newer Perl versions, with the latest change requiring at least Perl 5.38 and supporting up to Perl 5.42, ensuring that users can leverage the latest features and enhancements in their regex comparisons.

Test::Spelling::Stopwords is a Perl module designed to enhance POD (Plain Old Documentation) spell-checking by integrating project-specific stopwords with the established spell-checking tool, aspell. This module simplifies the process of managing stopwords by automatically discovering and loading a .stopwords file from the project root, eliminating the need for explicit declarations in test files. It features a two-layer architecture that combines a community-maintained vocabulary from Pod::Wordlist with project-specific terms, ensuring accurate spell-checking while providing precise line-number reporting for any misspellings found. Additionally, it includes a freshness check that warns users if the .stopwords file is outdated compared to the source files, and it strips POD formatting codes to prevent false positives during checks. The initial release of this module in March 2026 introduced these capabilities, making it a valuable tool for maintaining high-quality documentation in Perl projects.

Linux::Event is a specialized event loop framework designed for Linux environments, providing a robust and efficient way to handle asynchronous events. It leverages Linux-specific features such as epoll for I/O readiness, timerfd for timers, signalfd for signal handling, eventfd for wakeups, and pidfd for process exit notifications. The module offers a stable public API, allowing developers to create and manage event loops with minimal overhead and explicit semantics. Recent updates have improved the reliability of the loop's wakeup mechanism and fixed various issues related to timer management and backend interactions, ensuring a smoother experience for users. With its focus on performance and stability, Linux::Event is an excellent choice for developers looking to implement event-driven architectures in their applications.

The Data::MessagePack Perl module provides efficient serialization and deserialization of Perl data structures using the MessagePack format, which is a binary-based alternative to JSON that offers faster performance and smaller size. This module allows developers to easily convert Perl data into a compact binary format and back, making it suitable for applications requiring high-speed data exchange, such as networking and remote procedure calls (RPC). Key features include support for streaming deserialization, options for handling integers and UTF-8 strings, and the ability to enforce canonical packing by sorting keys. Recent updates have improved performance and fixed various issues, ensuring robust handling of data structures. For more information on MessagePack, visit the official website at <http://msgpack.org/>.

Langertha is a versatile Perl module designed to provide a unified interface for interacting with various Large Language Model (LLM) APIs, including popular providers like OpenAI, Anthropic, and Ollama. It abstracts the complexities of different API implementations, allowing developers to seamlessly integrate chat, streaming, embeddings, and other functionalities across multiple LLM engines. With features such as asynchronous processing, response metadata, and a plugin system for extending capabilities, Langertha facilitates the creation of sophisticated applications that leverage AI-driven interactions. Its modular architecture supports both local and cloud-based models, making it an ideal choice for developers looking to harness the power of AI in their Perl applications.