CPANscan

WebService::YTSearch is a Perl module designed to facilitate searching YouTube using the YouTube Data API. By providing your authorized API key, you can create an instance of the WebService::YTSearch object and utilize its search method to retrieve video results based on specified queries and parameters, such as the maximum number of results. This module simplifies the process of interacting with YouTube's search functionality, allowing developers to easily integrate video search capabilities into their applications. Additionally, it supports various commands beyond basic searches, enabling more complex interactions with YouTube's data.

ExtUtils::Builder::Compiler is a Perl module designed to provide a unified interface for interacting with various compilers, streamlining the process of compiling source code. While it is typically not used directly, it serves as a foundational component for portability layers like ExtUtils::Builder::Autodetect::C. The module offers methods to add include directories and define macros, as well as a compile method to transform source files into target binaries. This functionality is particularly useful for developers looking to manage compilation tasks in a consistent manner across different environments.

The `Params::Validate::Strict` Perl module provides a robust framework for validating input parameters against a defined schema, ensuring that data adheres to specified types and constraints. With its flexible schema definition capabilities, users can specify validation rules for various data types, including strings, integers, and complex nested structures. The module supports features such as coercion of input types, custom error messages, and transformations to sanitize data before validation. Additionally, it allows for cross-field validations, enabling complex business logic checks between multiple parameters. This makes it particularly useful for applications requiring strict input validation, such as web application firewalls and automated testing scenarios, while also enhancing API documentation clarity.

The App::Greple::xlate module is a powerful translation support tool designed for use with the greple command-line utility, enabling users to find and replace text blocks in Perl's POD format with translated content. It currently supports multiple back-end engines, including DeepL, ChatGPT 4.1, and GPT-5, allowing for flexible translation options. Users can specify patterns to identify text for translation, manage output formats, and utilize features like masking to exclude certain text from translation. Recent updates in version 0.9917 include enhancements for faster Docker image builds and improved concurrency control, making the translation process more efficient. This module is particularly useful for developers looking to automate the translation of documentation or code comments while maintaining version control compatibility.

The `Graphics::Framebuffer` Perl module is a straightforward graphics library designed for use in Linux, FreeBSD, and Unix console framebuffer environments. It allows developers to perform direct drawing operations on 32/24/16-bit framebuffers, enabling the creation of graphics without the complexity of APIs or drivers. The module supports a variety of drawing methods, including plotting pixels, drawing shapes like circles and polygons, and rendering text using TrueType fonts. It also features an emulation mode for systems without a framebuffer, allowing for offscreen drawing. Recent updates have introduced optimizations for performance, including an accelerated flood fill method, enhancing the module's efficiency in rendering graphics. This makes `Graphics::Framebuffer` a valuable tool for developers looking to create console-based graphical applications with minimal overhead.

Debug::Easy is a versatile Perl module designed to simplify the debugging process by providing colorized output and formatted logging. It allows developers to set various log levels, ranging from errors to detailed debug messages, making it easy to control the verbosity of output. The module automatically timestamps logs and benchmarks execution time, enhancing readability with indented and multiline formatting. Recent updates include improved handling of Data::Dumper for better output representation and relaxed requirements for Perl versions, ensuring broader compatibility. With its user-friendly features, Debug::Easy streamlines the debugging workflow, making it an essential tool for Perl developers.

The AWS::Lambda Perl module provides seamless integration for running AWS Lambda functions written in Perl, enabling developers to leverage Perl's capabilities within the AWS Lambda environment. With this module, users can create custom runtimes, utilize pre-built public Lambda layers, and even deploy applications using Docker images. It supports response streaming and includes pre-installed modules for convenience, such as AWS::XRay for tracing requests. Recent updates include the addition of support for tenant IDs in AWS::Lambda::Context and the marking of Amazon Linux 2-based layers as no longer maintained, encouraging users to migrate to the more current Amazon Linux 2023 environment. This module is ideal for Perl developers looking to harness the power of serverless computing on AWS.

Sys::Monitor::Lite is a lightweight system monitoring toolkit designed for easy automation and integration, providing structured output in JSON or YAML formats. It offers functions to collect various system metrics, including CPU and memory usage, and allows users to retrieve all available metrics or a specified subset. The module also includes serialization capabilities, enabling users to convert collected data into JSON or YAML strings for further processing with tools like jq-lite or yq. A noteworthy recent addition in version 0.03 is the support for YAML output, enhancing its versatility for users who prefer this format. With its minimalistic approach, Sys::Monitor::Lite is ideal for developers looking to implement straightforward system monitoring solutions.

SimpleFlow is a straightforward workflow manager and logger implemented in Perl, designed to facilitate the execution of tasks in a structured and error-checked manner, similar to tools like snakeMake or NextFlow. It allows users to define tasks with a command to execute, along with optional parameters such as input and output file checks, logging options, and error handling. Each task returns a comprehensive hash containing details like exit codes, working directories, and standard output/error, making it easy to track the execution of complex pipelines. SimpleFlow is particularly useful for automating workflows in scientific computing, where precision and clarity are paramount, ensuring that each step is validated and logged for easy debugging and analysis.

The Affix module provides a Foreign Function Interface (FFI) for Perl, allowing developers to seamlessly call functions and access variables from libraries written in other languages such as C, C++, and Rust without the need for XS. With a straightforward API, Affix enables users to bind exported functions and values to Perl subroutines, wrap them in code references, and define argument and return types using a signature system. It supports various features like memory management functions, type definitions, and ABI hints for handling name mangling in advanced languages. The module also includes a convenient ":Native" attribute for declaring native functions, making it easier to integrate external libraries into Perl applications. Overall, Affix is a powerful tool for Perl developers looking to leverage existing native code efficiently.

Net::Stripe is a Perl module that serves as a comprehensive API client for Stripe.com, enabling developers to easily integrate payment processing capabilities into their applications. With version 0.43, this module provides a robust interface for managing various Stripe resources such as charges, customers, subscriptions, and invoices, all while adhering to the structure of the Stripe API. The module employs Moose objects for API responses, ensuring a clean and object-oriented approach to handling data. Recent updates include improvements to form field serialization and the addition of a tax_id subkey for billing details, enhancing compatibility with the latest Stripe API features. This makes Net::Stripe an essential tool for developers looking to implement Stripe's payment solutions efficiently and effectively.

Env::Assert is a Perl module designed to ensure that your environment variables meet specific requirements, aborting execution if they do not. By utilizing an environment description file (defaulting to .envdesc), it allows you to define patterns for required variables, such as ensuring that a variable matches a certain regex. This module is particularly useful for developers who need to validate their environment setup before running applications, helping to prevent runtime errors caused by missing or incorrectly configured environment variables. With a straightforward API, Env::Assert can be easily integrated into your Perl scripts to enhance reliability and maintainability.

The Dev::Util module is a comprehensive toolkit designed to streamline the development of Perl programs by providing a standardized set of utilities. It encompasses various sub-modules that facilitate essential functionalities such as consistent feature setup, OS identification, file and directory management, user input prompts, and backup operations. With features like automatic inclusion of strict and warnings pragmas, named constants, and semaphore locking, Dev::Util enhances code maintainability and efficiency. This module is particularly useful for developers looking to simplify common tasks and ensure best practices across their Perl applications.

The `WWW::SnipeIT` Perl module provides a straightforward interface for accessing the Snipe-IT API, a popular asset inventory management system that can be deployed either on-premises or in the cloud. By utilizing this module, developers can easily interact with various aspects of asset management, such as retrieving hardware details by asset tag, updating asset information, and searching for hardware based on specific criteria. With its simple syntax and comprehensive functionality, `WWW::SnipeIT` streamlines the integration of Snipe-IT's capabilities into Perl applications, making it an essential tool for managing IT assets efficiently.

The JSON::Schema::Modern Perl module provides a robust and compliant way to validate data against JSON schemas, specifically targeting the latest Draft 2020-12 version of the JSON Schema specification. With its straightforward interface, users can create a new schema evaluator, configure various options such as output format and validation depth, and evaluate instance data against defined schemas. The module supports a range of features including custom format validations, early evaluation short-circuiting, and the ability to handle complex schemas with nested structures. It also allows for the registration of custom media types and encodings, making it a versatile tool for developers working with JSON data validation in Perl applications.

Marlin is a high-performance class builder for Perl that combines the features of Moose and Moo with a unique syntax, offering a fast and efficient way to create object-oriented classes. It leverages Class::XSAccessor, Class::XSConstructor, and Type::Tiny::XS for enhanced speed, particularly when using simple attributes. Marlin supports a wide range of features, including attribute declaration, type constraints, method delegation, and various accessors, while maintaining compatibility with older Perl versions as far back as 5.8.8. It allows for compile-time class construction without polluting the namespace with keywords, making it an excellent choice for developers looking for a lightweight yet powerful alternative to traditional object systems in Perl.

Lexical::Accessor is a Perl module designed to create truly private attributes for Moose, Moo, and Mouse object systems, ensuring that these attributes remain inaccessible from outside the class, including subclasses. By utilizing the `lexical_has` function, developers can define private attributes that are stored inside-out, allowing for complete encapsulation and preventing naming conflicts with attributes in subclasses. This module supports various options similar to Moose's `has`, such as defining read/write accessors, type constraints, and default values, while also offering performance benefits—being significantly faster than alternatives like MooX::PrivateAttributes and MooseX::Privacy. A noteworthy recent change in version 1.000000 includes optimizations to the Sub::Accessor::Small component, enhancing code efficiency, particularly for method delegations.

Alien::SDL3 is a Perl module designed to facilitate the building and installation of SDL3, a popular multimedia library used for game development and other graphical applications. While it provides a method to retrieve dynamic library files, it is not intended for direct use by developers; instead, it serves as a backend dependency management tool. Users should ensure that the necessary development libraries, such as X11 or Wayland, are present on their systems, particularly for Linux and BSD platforms. This module is maintained by Sanko Robinson and is distributed under the Artistic License 2.

DBIx::Class::DeploymentHandler is a powerful and flexible tool designed for deploying and upgrading databases in applications that utilize DBIx::Class. Unlike its predecessor, DBIx::Class::Schema::Versioned, this module offers enhanced capabilities such as support for downgrades, the ability to manage multiple SQL files for each upgrade or downgrade, and the option to use Perl scripts for database operations. It streamlines the deployment process by requiring only a single set of files for upgrades, significantly simplifying version management. Built on Moose and utilizing a modular architecture, DBIx::Class::DeploymentHandler allows developers to easily customize and extend its functionality while providing robust logging features to track operations. This makes it an essential tool for developers looking to maintain and evolve their database schemas efficiently.

The App::TimeTracker::Command::Jira module is a plugin for the App::TimeTracker application that facilitates integration with Atlassian Jira, enabling users to manage their tasks more efficiently. With this plugin, users can automatically set task descriptions and tags based on Jira ticket data, assign ticket ownership, and update work logs directly from the command line. Additionally, if used alongside the Git plugin, it can generate branch names that reflect Jira ticket information. Recent updates include the introduction of token-based authentication for enhanced security, allowing users to connect to Jira without exposing their passwords. This module is particularly useful for developers and teams who rely on Jira for project management and want to streamline their workflow.

File::XDG is a Perl module that implements the XDG base directory specification, which is designed to standardize the locations for user-specific configuration, data, and cache files across different applications. With version 1.03, it allows developers to easily access directories such as user configuration, data, and cache homes, as well as system-wide configuration and data directories. The module supports various path classes, including Path::Tiny and Path::Class, and offers methods for looking up configuration and data files based on the application name. Notably, the recent update in version 1.03 included an update to the license text, ensuring compliance and clarity for users. This module is particularly useful for developers looking to adhere to the XDG specification while managing application file paths in a consistent manner.

The User::Identity Perl module is designed to manage and maintain information about individual users, encapsulating various attributes such as names, birthdates, and gender in a flexible object-oriented structure. It allows developers to create user identity objects with a range of customizable fields, providing defaults and smart handling of data to ensure ease of use. The module supports stringification, enabling seamless integration into output contexts by automatically converting user objects to their full names. While it does not implement any storage mechanisms, it offers the flexibility to store user data using various Perl data serialization methods or databases. This makes User::Identity a versatile choice for applications requiring user information management without being tied to a specific data format.

The `Spreadsheet::Edit` Perl module provides a versatile interface for manipulating spreadsheet data, allowing users to read, modify, and write data from various formats such as Excel and CSV files. It supports both functional and object-oriented programming paradigms, enabling users to access spreadsheet columns by title or through dynamically created aliases. The module facilitates operations like sorting, inserting, deleting, and transforming columns and rows, while also allowing for the use of tied variables for seamless integration with Perl's variable system. With features for data manipulation inspired by tools like `sed` and `awk`, `Spreadsheet::Edit` is ideal for developers looking to automate spreadsheet tasks or perform complex data transformations efficiently.

The `Object::Realize::Later` Perl module facilitates the delayed creation of objects, allowing for on-demand realization of object data to enhance performance and reduce resource consumption. By implementing a lazy loading mechanism, this module enables developers to defer the instantiation of an object until its data is actually needed, which can significantly improve the startup time of applications. It provides a flexible interface for defining how and when an object should be realized, including options for handling method calls and warnings during the realization process. This makes it particularly useful for larger projects where efficiency is critical, as it allows for the management of object states without unnecessary overhead.

The `Business::ISBN::Data` module serves as a data pack for the `Business::ISBN` module, providing essential data derived from the ISBN Agency's `RangeMessage.xml` file. Typically, users do not need to load this module directly, as it is automatically loaded by `Business::ISBN`, which requires version 3.005 or later due to structural changes addressing ISBN-13 prefixes. The module allows for flexibility in data sourcing; users can specify an alternate `RangeMessage.xml` file via the `ISBN_RANGE_MESSAGE` environment variable, ensuring access to the most current or historical data without needing to update the module itself. If the specified data file is unavailable, it defaults to older data included within the module. The data is organized in the `%Business::ISBN::country_data` hash, which provides insights into the source of the data. This module is particularly useful for developers working with ISBNs, enabling them to manage and utilize ISBN-related data effectively.

The Perl module Module::Release is designed to automate the software release process, streamlining tasks such as version control, testing, and uploading to repositories like PAUSE (CPAN) and SourceForge. Originally developed as a script, it has evolved into a comprehensive tool that integrates with various build systems, including Makefile.PL and Module::Build, and supports multiple version control systems like CVS, SVN, and Git through mixins. The module provides a series of methods that check conditions (e.g., ensuring all tests pass) before proceeding with the release, ensuring that errors are caught early in the process. Recent updates include enhancements to the handling of GitHub metadata and improvements in the release process, making it easier for developers to manage their distributions effectively. With its flexible configuration options and robust functionality, Module::Release is an essential tool for Perl developers looking to streamline their release workflows.

Daje::Workflow is a straightforward workflow engine designed to manage processes as a series of states and transitions triggered by events. It allows developers to define workflows with various activities, each leading to a resulting state, making it easy to model complex processes in a clear and organized manner. The module requires several components, including database models and error handling, to function effectively. Recent updates in version 0.24 include bug fixes, the merging of the Daje::Workflow::Loader and Daje::Workflow::Config modules, and the addition of pre and post activity checks, enhancing its robustness and usability for developers looking to implement workflow management in their applications.

Daje::Plugin::Workflow is a Mojolicious plugin designed to integrate with Daje::Workflow, enabling developers to manage and execute workflows within their applications seamlessly. By utilizing this plugin, users can easily configure workflow loaders, specifying paths and types for their workflow files, thus streamlining the process of workflow management. It requires several components, including Daje::Workflow and its associated loaders and database modules, ensuring a robust framework for workflow operations. This plugin is ideal for developers looking to enhance their Mojolicious applications with powerful workflow capabilities.

Daje::Plugin::Tools is a Mojolicious plugin designed to enhance the functionality of Mojolicious applications by providing a suite of tools and database models essential for managing various aspects of application data. It requires several database helpers and models, ensuring a robust integration with the Daje framework. The plugin can be easily registered within a Mojolicious application or used in Mojolicious::Lite, making it versatile for different development environments. Recent updates in version 0.25 include critical bug fixes, the relocation of migrations to Daje::Database::Tools, and corrections to dependencies and tests, ensuring improved stability and performance for developers utilizing this plugin.

The SPVM::Regex module provides a powerful interface for working with regular expressions in Perl, leveraging the Google RE2 engine for efficient pattern matching and string manipulation. It offers methods for matching patterns, replacing substrings, and splitting strings based on regex patterns, all while supporting UTF-8 and various regex features. Users can create Regex objects with custom patterns and flags, perform matches with optional offsets and lengths, and utilize both simple and callback-based replacements. Recent updates include bug fixes that enhance pattern matching capabilities, particularly for edge cases involving anchors like `\A` and `\z`, ensuring more reliable behavior in string processing tasks. This module is ideal for developers looking to integrate robust regex functionality into their SPVM applications.