CPANscan

Bundle::Maintainer::MHASCH is a Perl module that serves as a convenient collection of CPAN modules maintained by Martin Becker (MHASCH). This bundle simplifies the installation process by allowing users to install all the listed modules at once using a single command through CPAN. It includes various mathematical modules such as Date::Gregorian and several polynomial-related modules, making it particularly useful for developers who require these specific functionalities. While bundles like this one provide an easy way to gather related modules, they are less flexible than modern meta-modules, which can handle complex dependencies. Nonetheless, Bundle::Maintainer::MHASCH is an excellent resource for anyone looking to quickly set up a development environment with the essential tools maintained by Becker.

The Date::Holidays::AU Perl module provides a straightforward way to determine public holidays in Australia, utilizing the interface defined by Date::Holidays::Abstract. With its primary functions, `is_holiday` and `holidays`, users can easily check if a specific date is a holiday in a given Australian state or retrieve a list of holidays for that year. The module supports various states, including Victoria, Queensland, and New South Wales, and allows for customization through parameters specific to each state. Ideal for developers needing to incorporate holiday data into their applications, Date::Holidays::AU simplifies the process of holiday management across Australia.

App::GitKtti is a Perl module designed to enhance Git branch management by providing a suite of command-line tools that facilitate safe and efficient use of the Git flow methodology. With features such as safe branch operations, colorized output for improved readability, and support for various workflows including feature, hotfix, and release, App::GitKtti streamlines the process of managing branches. It also includes automatic branch cleanup and management, making it an essential tool for developers looking to maintain a clean and organized Git repository.

The CPANSA::DB module provides a Perl data structure containing the CPAN Security Advisory (CPANSA) reports, primarily intended for use with the CPAN::Audit module. By calling the `db` subroutine, users can access a hash reference of all CPANSA reports, which are crucial for ensuring the integrity and security of Perl modules. Each release of this module is accompanied by a GPG signature for verification, and users can also utilize GitHub Attestations to confirm the authenticity of the downloaded files. This module is available on GitHub, where it includes detailed release information and attestation capabilities, making it a vital tool for developers concerned with the security of their Perl applications.

Math::GMPz is a Perl module that provides an interface to the GNU Multiple Precision Arithmetic Library (GMP), specifically for handling large integers (mpz). This module wraps nearly all integer functions available in the GMP library, allowing users to perform arithmetic operations, comparisons, and conversions on arbitrarily large integers with ease. It supports various initialization methods for creating bignum objects, automatic memory management, and includes functions for random number generation, formatted input/output, and number-theoretic calculations. With its extensive functionality and reliance on the efficient GMP library, Math::GMPz is ideal for applications requiring high-performance arithmetic on large integers.

Net::Async::Kubernetes is an asynchronous client for interacting with Kubernetes clusters, designed to work seamlessly with the IO::Async framework. This module simplifies Kubernetes operations by providing non-blocking CRUD (Create, Read, Update, Delete) methods that return Future objects, allowing for efficient handling of asynchronous tasks. Users can easily configure the client using a kubeconfig file, in-cluster service account tokens, or explicit server and credential parameters. The module also features a robust watcher mechanism that supports auto-reconnection and event streaming, enabling real-time monitoring of Kubernetes resources with customizable callbacks for added, modified, and deleted events. Notably, version 0.004 introduced enhancements for automatic detection of kubeconfig and in-cluster service accounts, streamlining the client setup process.

Kubernetes::REST is a Perl module that serves as a REST client for interacting with the Kubernetes API, providing a simplified interface for managing Kubernetes resources. With this module, users can easily perform operations such as listing, creating, updating, patching, and deleting resources like Pods and Namespaces, all while leveraging the automatic URL building capabilities of IO::K8s resource classes. The module supports dynamic loading of resource maps from the cluster's OpenAPI specification, ensuring compatibility with various Kubernetes versions. Notably, the recent version 1.003 introduced automatic detection of in-cluster service account tokens, allowing seamless operation within Kubernetes pods without requiring a kubeconfig file. This enhancement significantly simplifies authentication for applications running in Kubernetes environments.

The `IO::K8s` Perl module provides a comprehensive interface for interacting with Kubernetes API objects, enabling users to easily create, manipulate, and serialize Kubernetes resources. With features such as loading and validating YAML manifests, programmatically creating objects, and inflating JSON data into typed Perl objects, `IO::K8s` streamlines the process of working with Kubernetes configurations. The module supports both built-in Kubernetes types and custom resource definitions (CRDs), allowing for flexible integration with various Kubernetes setups. Recent updates have improved JSON deserialization by fixing issues with recognizing sanitized field names, enhancing the module's robustness when handling complex Kubernetes structures. This makes `IO::K8s` an essential tool for developers looking to automate and manage Kubernetes resources effectively.

The TimeDate Perl module provides a comprehensive suite of date and time handling functionalities, including parsing, formatting, and timezone management. With its core components—Date::Parse for converting various date string formats into Unix timestamps, Date::Format for formatting timestamps into human-readable strings, and Date::Language for multi-language support—TimeDate is versatile for international applications. The module also includes Time::Zone for timezone offset lookups. Recent updates in version 2.34 have enhanced documentation coverage, fixed language data bugs, and introduced support for the boost C++ timestamp format, making it even more robust for developers needing precise date and time manipulation in their Perl applications.

The "Future::IO::Impl::Tickit" module provides an implementation of the Future::IO interface using the Tickit framework, enabling asynchronous I/O operations within a Tickit application. To utilize this module, developers must first create a Tickit instance and set it using the `set_tickit` method, ensuring that the Future::IO functionalities can operate correctly. Recent updates include enhancements to support the latest Future::IO features, such as the addition of the `->poll` method and improved test compatibility, while also addressing limitations regarding the POLLPRI constant, which is not currently supported by libtickit. This module is particularly useful for developers looking to integrate asynchronous I/O capabilities into their Tickit-based applications.

"Future::IO::Impl::Glib" is a Perl module that serves as an implementation of the Future::IO framework using Glib, making it an ideal choice for integrating asynchronous I/O operations within Glib or Gtk applications. By simply loading this module alongside Future::IO, developers can leverage its functionality to handle non-blocking I/O tasks seamlessly, enhancing the responsiveness of their applications without the need for additional methods. This module is particularly useful for those looking to utilize the capabilities of Glib in a straightforward manner, allowing for efficient event-driven programming in Perl.

The Net::Correios Perl module provides a convenient interface for accessing the Brazilian Postal Service's REST API, enabling developers to perform various operations such as querying postal codes (CEPs), calculating shipping prices and delivery times, and tracking packages. Designed primarily for Brazilian developers, this module requires an active commercial contract with Correios and an API key for authentication. With methods to retrieve information about shipping costs, delivery deadlines, and tracking status, Net::Correios simplifies the integration of postal services into applications, making it an essential tool for businesses and developers working with logistics in Brazil.

The `Time::ParseDate` Perl module is designed for parsing both relative and absolute date and time strings into seconds since January 1, 1970. It supports a wide variety of date formats, including common styles like "dd/mm/yyyy" and "yyyy-mm-dd," as well as relative formats such as "next Tuesday" or "3 days ago." The module offers numerous options to customize parsing behavior, such as handling time zones, requiring complete date strings, and allowing for fuzzy matching of input. A notable recent update in February 2026 added support for trailing "Z" or "z" to denote UTC in ISO 8601 timestamps, enhancing its compatibility with modern date formats. This module is particularly useful for applications that need to interpret and manipulate date and time information flexibly and accurately.

The "Test::Future::IO::Impl" Perl module provides a suite of acceptance tests designed for implementations of the "Future::IO" framework. It allows developers to ensure that their custom implementations adhere to the expected behavior of various I/O methods, such as `accept`, `connect`, `poll`, `recv`, `send`, and others. By utilizing the `run_tests` function, users can execute specific test suites against their implementation, ensuring compatibility and correctness. Recent updates, including version 0.20, have improved testing related to `POLLHUP`, enhancing the reliability of the tests across different operating systems. This module is essential for developers looking to validate their I/O implementations within the Future::IO ecosystem.

The Curses module provides a Perl interface to the system's curses library, enabling terminal screen handling and optimization for text-based user interfaces. It simplifies the usage of various curses functions by unifying multiple variants into single, more flexible functions that accept optional window and coordinate parameters, making it easier for Perl developers to create interactive applications. The module also includes wide-character-aware functions for better handling of multi-byte character encodings, enhancing compatibility with modern text formats. Recent updates include the addition of BUTTON5 constants in version 1.46, which expands the module's capabilities for handling mouse events. Overall, Curses is an essential tool for Perl developers looking to build robust terminal applications with advanced screen management features.

The "Tickit" module is a high-level toolkit designed for creating interactive, full-screen terminal applications in Perl. It provides a structured way to build user interfaces using a tree of widget objects, allowing developers to define layouts and behaviors abstractly. Tickit supports advanced terminal features such as rich text rendering, mouse interactions, and asynchronous input handling, making it suitable for modern terminal applications. With its ability to manage multiple instances and non-blocking operations, Tickit simplifies the development of complex terminal interfaces, enabling developers to focus on functionality rather than low-level terminal management.

Class::Enumeration is an abstract parent class designed for creating enumeration classes in Perl, providing a structured way to define immutable enum objects with associated names and ordinal values. It offers essential methods such as `name()` and `ordinal()` for accessing the properties of enum objects, as well as class methods like `names()` and `values()` for retrieving lists of enum names and objects, respectively. While this class should not be used directly, it serves as a foundation for more specific enum implementations via the Class::Enumeration::Builder module. Recent updates in version 1.3.0 introduced a 'to_json' builder option, enhancing the module's functionality for JSON serialization.

"Future::IO::Impl::KQueue" is a Perl module that implements the Future::IO interface using the kqueue(2) and kevents(2) system calls, leveraging the IO::KQueue functionality. This module does not introduce any new methods; instead, it seamlessly integrates with Future::IO, allowing developers to utilize asynchronous I/O operations in their applications. By simply loading this module alongside Future::IO, users can easily manage future events and asynchronous tasks, making it a valuable tool for building efficient, non-blocking I/O applications in Perl.

The `nup` Perl module is a versatile tool designed for generating multi-column paged output from files or commands, enhancing readability and organization. It automatically determines whether to display a file or execute a command based on the input, with options to customize the layout, such as setting the number of columns and rows, adjusting pane width, and selecting various border and line styles. Users can also enable features like parallel view mode, document mode, and folding mode for a more streamlined output experience. With support for color mapping and predefined display themes, `nup` is ideal for users looking to improve the presentation of command-line outputs or file contents in a visually appealing manner.

Test::PostgreSQL::v2 is a modern Perl module designed to facilitate the creation and management of isolated PostgreSQL instances for testing purposes. This module serves as a robust replacement for the older Test::PostgreSQL, addressing contemporary Linux environment challenges by isolating socket directories and ensuring compatibility with modern PostgreSQL binaries. With its straightforward interface, users can easily start a temporary PostgreSQL instance, connect via DBI, and execute SQL commands, all while benefiting from automatic cleanup when the instance goes out of scope. Notably, version 2.03 includes improvements to the documentation, while earlier updates introduced significant features such as enhanced error handling, automatic port selection, and better process management, making it an essential tool for developers utilizing Test::DBIx::Class for ORM-based testing.

Geo::Location::TimeZoneFinder is a Perl module designed to map geographic coordinates to their corresponding time zone names, such as "Asia/Shanghai". Utilizing database files from the Timezone Boundary Builder project, this module allows users to easily retrieve time zone information based on latitude and longitude inputs. With methods for creating a new finder object and querying time zones, it ensures accurate results while handling various edge cases, such as disputed areas with multiple time zones. A noteworthy recent update in version 1.002, released on February 25, 2026, enhances the module by converting coordinates passed as strings into numeric values, improving usability and robustness.

The Perl module Number::ZipCode::JP provides a straightforward way to validate Japanese zip codes according to the regulations set by Japan Post Holdings Co., Ltd. It allows users to create instances of zip codes, set their values, and check their validity based on specified categories, such as area-specific or company-specific zip codes. The module supports various input formats, including those with non-numeric characters, and can be easily integrated into applications that require zip code validation. Recent updates have focused on refining the underlying table classes used for validation, ensuring that the module remains accurate and reliable for users.

The Cucumber::Messages Perl module provides a comprehensive library for handling Cucumber messages, which are essential for communication within the Cucumber ecosystem. This module facilitates the serialization and deserialization of messages to and from NDJSON format, allowing Perl applications to effectively manage the in-memory representation of various Cucumber message types. Key features include the ability to create and manipulate message classes such as `Envelope`, `Attachment`, `TestCase`, and `Step`, among others, enabling developers to work seamlessly with Cucumber's protocol for defining and executing tests. By utilizing this module, developers can enhance their testing frameworks with structured messaging capabilities that align with Cucumber's specifications.

The `Compress::Raw::Lzma` Perl module provides a low-level interface to the LZMA compression library, enabling efficient in-memory compression and decompression of data. It offers various encoder and decoder classes, such as `EasyEncoder`, `StreamEncoder`, and `AutoDecoder`, allowing users to choose the appropriate method based on their needs. The module supports multiple compression options, including preset levels and custom filters, making it versatile for different use cases. Recent updates include improvements to documentation and fixes for minor issues, ensuring better usability and performance. This module is particularly useful for developers looking to integrate LZMA compression into their Perl applications, either directly or through higher-level modules like `IO::Compress::Lzma`.

The Perl::Version::Bumper module is designed to facilitate the updating of Perl code to declare a more recent version of the Perl language using the "use VERSION" directive. It simplifies the process by automatically removing unnecessary feature and experimental warnings, adding the appropriate "use VERSION" line at the top of the file, and managing the removal of compatibility modules when their features are fully supported in the target Perl version. The module ensures that if the code already specifies a Perl version, it can only be upgraded to a higher version. Additionally, it offers safe methods that check the resulting code for compilation errors, allowing developers to incrementally bump the version while ensuring compatibility. This makes Perl::Version::Bumper an essential tool for maintaining and modernizing Perl codebases efficiently.

The Perl module `Alien::libmaxminddb` is designed to facilitate the discovery and installation of the C library `libmaxminddb`, which is essential for reading MaxMind DB files used in geolocation services. This module is particularly useful for developers who need to integrate geolocation capabilities into their applications, as it provides methods to retrieve the necessary compiler and linker flags for building XS modules that depend on `libmaxminddb`. Recent updates, including version 2.002, have improved the search functionality for the distribution's shared directory and updated the library to version 1.13.2, ensuring compatibility with the latest features and fixes.

Geo::IPfree is a Perl module designed for geolocation services, allowing users to determine the country of origin for any given IPv4 address. By utilizing a local file-based database, it provides efficient lookups for both IP addresses and hostnames, returning the corresponding ISO 3166 country code and name. The module includes features for optimizing performance, such as caching recent lookups and loading the entire database into memory for faster access. Recent updates in version 1.160001 have addressed issues with incorrect country returns and improved documentation, ensuring a more reliable user experience. This module is particularly useful for applications that require geographic data based on IP addresses, such as web analytics and security monitoring.

Tree::STR is a Perl module designed for creating a Sort-Tile-Recursive (STR) tree, which serves as a read-only R-Tree optimized for efficient construction. It allows users to index spatial data by providing bounding box coordinates in an array format, making it suitable for applications that require spatial queries. With methods like `query_point` and `query_partly_within_rect`, users can easily retrieve items based on spatial intersections. Notably, in version 0.06, the module's query methods were enhanced for compatibility with Tree::R, allowing for more flexible data handling by accepting an array reference for results. This makes Tree::STR a powerful tool for developers working with spatial data in Perl.

Mail::DMARC is a comprehensive Perl module designed to implement Domain-based Message Authentication, Reporting, and Conformance (DMARC) protocols, adhering to the latest specifications. It provides tools for validating incoming email messages against DMARC policies, allowing mail transfer agents (MTAs) and filtering applications to ensure that messages align with the sender's authentication policies. The module facilitates the generation and reception of DMARC reports, enabling email senders and MTA operators to manage and analyze email authentication results effectively. With features for storing reports in various SQL databases and methods for viewing and sending reports, Mail::DMARC is an essential tool for enhancing email security and compliance with DMARC standards.

Getopt::EX::Hashed is a Perl module designed to streamline the management of command line options using Getopt::Long by automating the creation of a hash object that stores option values. It allows developers to define command line parameters in a concise manner, integrating both initialization and specification into a single declaration. The module automatically generates accessor methods for these parameters, supports validation through various built-in checks, and offers configuration options to customize behavior, such as locking hash keys and managing accessors. This makes it an efficient tool for building command line applications in Perl, simplifying the process of handling user input and ensuring data integrity.