CPANscan

Google::Cloud::Sql::V1 is a Perl client that lets you call the Google Cloud SQL Admin V1 API from Perl programs using a high-performance gRPC transport, making it easy to manage Cloud SQL resources programmatically. It is auto-generated from the protocol buffer schema and integrates with Google::Auth for credential handling, providing service-specific classes and example usage for both transport modes so you can match your environment; the package is newly released and maintained to track the upstream API. The module is distributed under the Apache 2.0 license and is most relevant if you need a direct, up-to-date Perl binding to Cloud SQL administration functions.

Google::Cloud::Secretmanager::V1 is a Perl client library for Google Cloud Secret Manager that lets Perl applications store, retrieve, and manage secrets through the V1 API. It uses a high-performance gRPC transport and integrates with Google::Auth for credentials so you can add centralized, auditable secret storage and programmatic access to secret versions in your server or cloud applications. The module is suitable when you need secure, cloud-native secret management from Perl code and is released under the Apache 2.0 license.

Google::Cloud::Privateca::V1 is a Perl client library for version 1 of Google Cloud's Certificate Authority Service (Private CA). It provides a straightforward way for Perl applications to talk to Google Private CA over a high-performance gRPC transport, enabling integration of certificate authority operations into automation and services such as creating and managing private CAs, issuing and revoking certificates, and querying certificate status. The module uses Google::Auth for authentication and follows the Google Cloud API surface for Private CA, and it is distributed under the Apache 2.0 license.

Google::Cloud::Iam::V1 is a Perl client library for interacting with Google Cloud Identity and Access Management (IAM) V1 over a high-performance gRPC transport. It integrates with Google::Auth for credentials and exposes the IAM API so you can manage roles, policies, permissions, and related access-control tasks from Perl code, making it useful for automating or embedding IAM operations in scripts and services. The module is focused on providing direct, programmatic access to Google Cloud IAM and is released under the Apache 2.0 license.

Google::Cloud::Datafusion::V1 is a Perl client library that lets Perl applications interact with the Google Cloud Data Fusion V1 API using a high-performance gRPC transport. Paired with Google::Auth credentials it enables you to perform Data Fusion operations from Perl code so you can automate and integrate tasks such as creating and managing Data Fusion instances and pipelines without working with raw HTTP calls. The module is intended for developers and administrators who need to control Data Fusion from Perl and is distributed under the Apache 2.0 license.

App::Tarotplane is the core Perl library behind tarotplane, a curses-based flashcard program, and it handles application initialization from command-line options and runs the interactive study session. It exposes simple methods to initialize and run the program and a testing-oriented accessor for inspecting internal settings, and it supports configurable card ordering including file order, random shuffle, and alphabetical order. If you need a terminal flashcard tool or want to embed, extend, or test tarotplane behavior from Perl, this module provides the essential interface.

Database::Abstraction is a lightweight, read-only Perl ORM-style layer that gives a consistent, SQL-free API for reading data from a variety of backends including CSV/PSV, XML, SQLite, BerkeleyDB, and now DBM::Deep or any DBI datasource via a DSN. You subclass it per table and call familiar methods like fetchrow_hashref, selectall_arrayref, count, or use the fluent query builder to compose where/order_by/limit chains, and AUTOLOAD provides quick column lookups; criteria support includes comparison operators, pattern matching, set membership, logical groupings, and automatic JOINs. Small files can be slurped into memory for very fast lookups and the module optionally caches results with a CHI-compatible cache and supports simple logging and schema introspection. Recent 0.37 enhancements add transparent remote file fetching via a host parameter (SSH/SCP into a temp dir), first-class DBM::Deep support with in-memory fast paths, and a security fix to validate key column names on object cloning. Note the module is read-only, the default CSV separator is "!" so set sep_char => "," for standard CSVs, XML slurp only handles simple flat structures, slurp mode assumes a unique key column, BerkeleyDB has limited features (no joins or chained queries), and column names must be valid SQL identifiers.

POE::Component::MetaCPAN::Recent is a small POE component that watches MetaCPAN for newly uploaded CPAN distributions and emits a POE event for each new upload. It polls the MetaCPAN recent feed and posts each discovered upload to an event name you supply when calling spawn so you can hook into existing POE sessions to log, notify, trigger tests, or update services. Spawn requires an event name and optionally a target session and the returned object provides session_id and shutdown methods. Each output event delivers the upload as a hashref in ARG0. Recent updates add a Digest::SHA prereq and a cache of seen AUTHOR/DIST pairs to avoid duplicate reports when the upstream feed provides buggy timestamps. This module is useful for CPAN authors, continuous integration, monitoring, or any automation that needs to react to newly published distributions.

Data::TimingWheel::Shared implements a shared-memory hashed timing wheel that lets you schedule and cancel large numbers of discrete-tick timers in constant time, making it useful for event loops, network stacks, and multi-process job schedulers where O(1) timer management matters. Timers carry a 64-bit payload and live in a fixed-size pool defined by a number of slots and a capacity, you add timers for a delay in ticks and call advance to move the clock and collect fired payloads in order. The wheel can be shared between processes via a backing file, an anonymous mapping inherited across fork, or a memfd passed between processes, and updates are protected by a futex-based write-preferring rwlock that provides crash-recovery for most cases. It is Linux-only and requires 64-bit Perl, and you should size the slots and capacity to your workload because the structure is fixed-size and will croak if full.

Data::Sync::Shared offers a compact suite of Linux-only, 64-bit-Perl synchronization primitives built on file-backed mmap and futexes so multiple processes can coordinate efficiently without pthreads. It implements five usable primitives—a counting Semaphore, a Barrier rendezvous, a reader-writer RWLock, a Condvar with a built-in mutex, and a Once one-time initialization gate—and supports anonymous, file-backed and memfd modes plus optional eventfd hooks for integration with event loops. The API gives timeouts on blocking ops, scope-based guard objects that auto-release locks, and crash-safety features that detect dead PIDs and recover most stuck locks, with a per-process reader-slot mechanism to prevent readers from pinning writers in normal use. If you need cross-process resource limiting, coordinated startup, reader/writer exclusivity, or condition waiting between forked workers, this module is directly relevant. Recent 0.07 fixes a bug where guards in forked children could release their parent’s lock and now ensure guards only release locks they acquired, and note that the on-disk format was bumped so older maps must be recreated and acquire_n now rejects requests above the configured maximum.

Data::Stack::Shared is a Linux-only, 64-bit-Perl module that provides a high-performance, shared-memory LIFO stack for multi-process programs. It offers int64 and fixed-length string variants and supports anonymous, memfd, or file-backed mappings so separate processes can push, pop, peek, and block with optional timeouts while sharing data without heavy locking. The implementation uses atomic operations and futex waits for multi-producer / multi-consumer safety, exposes capacity and statistics, supports eventfd notifications, and includes a concurrency-safe drain operation. Note that on-disk files use a new v2 format so older v1 stacks are incompatible. Recent releases hardened file permissions and fixed corner-case hangs and reclaim bugs so abandoned peers no longer block push/pop; drain can also force-recover slots stuck in "writing" after about two seconds, which in rare cases may discard a publish-in-flight.

Data::SpatialHash::Shared is a Linux-only, 64-bit Perl module that implements a concurrent, mmap-backed spatial hash so multiple processes can share a fast proximity index for 2D or 3D points. It stores positions in a cell grid and exposes efficient radius, k-nearest, box and cell queries, bulk insert/move operations, batched radius queries, and pair/collision emitters, with helpers for toroidal wrap, true 3D globe geometry and cube-sphere chunk/LOD ids. Access is synchronized with a futex read/write lock that supports crash recovery so readers and writers in separate processes can safely share the map, and it integrates with eventfd for external event loops. Maps may be anonymous, file-backed, or memfd-backed and include tuning knobs for cell size and bucket count plus runtime stats. Caveats the author notes are that it is Linux-only, requires 64-bit Perl, very old on-disk files are refused after a recent format upgrade so you must recreate prior maps, and the lock recovery has a rare PID-reuse edge case and a 1024-reader slot limit that can affect extreme deployments. Recent releases hardened security and robustness and changed the on-disk format while making newly created backing files private by default (mode 0600), with an option to supply a different file mode for cross-user sharing.

Data::SegmentTree::Shared provides a fast, shared-memory segment tree you can open from a file, memfd, or inherit across fork to hold a fixed array of signed 64-bit integers and perform range updates and queries in O(log n) time. It supports point set/add, range add, range assign, and range queries for sum, min, and max, and when built with assign-only updates it also offers gcd and product monoids; range_add/add permanently disable gcd/product and product will croak on 64-bit overflow. The structure uses lazy propagation so updates touch only a few nodes and a futex-based write-preferring rwlock lets many readers proceed concurrently while writers serialize, making it practical for multi-process use on Linux with 64-bit Perl. Be aware that mutations are not transactional so a writer killed mid-update can leave the tree internally inconsistent and should be treated as undefined until rebuilt, and the reader-slot table holds 1024 entries so extreme reader counts can create rare recovery issues. Recent 0.02 changes add range_assign and the gcd/product monoids and introduce an on-disk format change that prevents older files from being reopened.

Data::RoaringBitmap::Shared is a Linux-only, 64-bit-Perl module that implements a memory-shared Roaring bitmap — a compact, compressed set of 32-bit unsigned integers that can be accessed concurrently from multiple processes. It splits the 32-bit space into 16-bit buckets and stores the low 16 bits in per-bucket containers that are either sorted uint16 arrays or 65536-bit bitmaps, each occupying a fixed slot from a preallocated pool, so storage and performance adapt to sparse or dense data while capacity stays predictable. You can share a single bitmap across processes via a backing file, an inherited anonymous mapping after fork, or a memfd descriptor, and the API provides add, add_many, remove, contains, cardinality, min/max, to_array, and in-place union and intersect operations with a futex-based write-preferring rwlock that recovers from dead writers. Be aware that capacity is fixed at creation and pool exhaustion causes operations to croak, bitmap containers are not down-converted back to arrays in this version, xor/andnot and run containers are not yet supported, and there is a reader-slot table limit (1024) that makes a pathological crash scenario unlikely but possible. Recent 0.03 updates fixed a use-after-free bug in union/intersect, hardened security and robustness, and bumped the on-disk format to a new version so older 0.02 files are refused and must be recreated.

Google::gRPC is a high-performance gRPC client library for Perl that makes it easy to connect Perl applications to gRPC services. It provides the plumbing you need for reliable RPCs, including channel management and pooling, message framing and streams, deadline and status handling, and hooks for different transport engines. The distribution organises these capabilities into focused components such as Client, Channel, ChannelPool, Stream, Deadline, Status, and Engine so you can assemble a robust client for calling modern APIs like Google Cloud services. It is maintained under the Apache 2.0 license.

Protobuf is a Perl binding that brings high-performance Google Protocol Buffers to Perl by using the upb C library. It provides the familiar protobuf workflow for Perl developers, including generated message classes, a DescriptorPool for loading descriptors, and an Arena for efficient memory management, so you can create, serialize, and parse compact binary messages from Perl code with emphasis on speed and efficiency. The implementation aims to align closely with the official Python UPB-based extension, making it a strong choice when you need low-latency, high-throughput protobuf handling or interoperability with systems using Protocol Buffers.

Module::Starter::Protobuf is a Module::Starter plugin that automates creating skeletal CPAN distributions from proto3 files so you can quickly produce Perl client libraries for gRPC services. It runs protoc with the upb plugin to generate low level serialization classes and then scaffolds idiomatic, high level client wrapper modules with gRPC call methods, plus a dynamic integration test and a mocked Google::gRPC::Client constructor. The plugin also injects common runtime dependencies into the generated Makefile.PL and accepts protobuf input via arguments or the PROTOBUF_FILES environment variable, making it useful when you need a fast, consistent starting point for publishing Perl bindings for Protocol Buffers and gRPC services.

Google::Cloud::Storage::V2 is a Perl client for the Google Cloud Storage V2 API that talks to Google’s services over a high-performance gRPC transport. You instantiate it with Google::Auth credentials and then use the generated client classes to interact with buckets and objects from Perl programs, making it a good fit for server-side scripts and services that need efficient access to Cloud Storage. The client is auto-generated from the protocol buffer schema so it closely mirrors the official API, and it is released under the Apache 2.0 license. This distribution is new and actively generated from upstream protobufs, with the recent 0.03 update improving generated documentation and service class layout.

Google::Cloud::Spanner::V1::SpannerClient is a Perl client for the Google Cloud Spanner V1 API that lets Perl applications interact with Spanner databases to create sessions, run SQL queries, read and write rows, manage transactions and commits, and work with advanced features like change streams. It exposes the service surface and typed message objects you expect from Spanner such as Mutations, ResultSets, Transactions and QueryPlans so you can map your application operations directly to the database API. This module is a generated gRPC/protobuf client, so it is best suited for developers who need programmatic, low-level access to Cloud Spanner from Perl and who can supply Google Cloud credentials and network access to their Spanner instances.

Google::Cloud::PubSub::V1 is a Perl client for the Google Cloud Pub/Sub V1 API that uses a high-performance gRPC transport to let Perl programs publish messages, subscribe to topics, and manage subscriptions. The module is auto-generated from the protocol buffers schema and exposes service classes that mirror the Pub/Sub API, so you instantiate a client with Google::Auth credentials and call the usual publish and subscription methods without dealing with low-level gRPC plumbing. It is aimed at developers who need low-latency, programmatic access to Pub/Sub from Perl and includes documentation with dual-transport examples. The code is Apache 2.0 licensed and the recent 0.03 release notes indicate regenerated clients with separate service classes and improved POD documentation.

Google::Cloud::NetworkServices::V1 is a Perl client for Google Cloud Network Services V1 with a focus on Secure Web Proxy functionality. It gives Perl applications a straightforward way to call the Network Services API over high-performance gRPC and integrates with Google::Auth for credential handling. The package is auto-generated from Protocol Buffers so it exposes the service methods you need to manage proxy and network resources in Google Cloud while including usage examples for different transports. It is released under Apache 2.0 and is a new, actively maintained binding that is suitable for developers who need programmatic access to Google Cloud Network Services from Perl.

Google::Cloud::NetworkSecurity::V1 is a Perl client library for Google Cloud's Network Security V1 API that uses gRPC for high-performance, low-latency calls and integrates with Google::Auth for authentication. It provides generated service classes so your Perl code can manage Network Security resources such as address groups without working directly with protobufs or raw HTTP calls. The module is auto-generated from the protocol buffer schema, is available under the Apache 2.0 license, and includes example documentation showing gRPC and alternate transport usage. The recent 0.03 release added separate service classes, fixed regexes, and improved POD with dual-transport examples and encoded proto path information.

Google::Cloud::Metastore::V1 is a Perl client for the Google Cloud Dataproc Metastore V1 API that lets Perl programs manage Dataproc Metastore services and related metadata over a high-performance gRPC transport. It integrates with Google::Auth for obtaining credentials and is suitable for tasks like creating, inspecting and controlling metastore services and long‑running operations from Perl code. The client is autogenerated from Protocol Buffers so it follows the official API surface closely and includes generated documentation and examples for gRPC and alternate transports. The module is newly released (0.03), actively regenerated as the API evolves, and is distributed under the Apache 2.0 license.

Google::Cloud::Dataproc::V1 is a Perl client for the Google Cloud Dataproc V1 API that uses high-performance gRPC to let your Perl code talk to Dataproc services. It integrates with Google::Auth for credentials so you can programmatically manage Dataproc resources such as clusters and jobs from scripts or applications. The module targets V1 of the API and is distributed under the Apache 2.0 license.

Google::Cloud::Dataplex::V1 is a Perl client for the Google Cloud Dataplex API that lets Perl applications interact with Dataplex resources over a high-performance gRPC transport. It is intended for developers who need to manage Dataplex concepts such as lakes, zones, assets and related services from Perl code and works with Google::Auth for credentials so you can call the API securely from scripts or services. The client is auto-generated from Protocol Buffers, provides service-specific classes for the various Dataplex endpoints, and includes documentation and examples for both gRPC and alternate transports. The module is released under the Apache 2.0 license and recent updates regenerated the clients into separate service classes, fixed regex handling, and improved the generated POD including dual-transport examples to make getting started easier.

Google::Cloud::Dataflow::V1Beta3 is a Perl client for the Google Cloud Dataflow V1Beta3 API that uses a high-performance gRPC transport to let Perl applications create, manage, and monitor Dataflow jobs and pipelines programmatically. It integrates with Google::Auth for authentication and is designed for developers who want to embed Dataflow operations into scripts, automation, or backend services. The module targets the V1Beta3 API surface and is distributed under the Apache 2.0 license.

Google::Cloud::Compute::V1 is a Perl client for the Google Cloud Compute Engine V1 API that uses a high-performance gRPC transport to let Perl applications authenticate with Google::Auth and make calls to Compute Engine services. The distribution is auto-generated from Protocol Buffers and provides separate service classes and up-to-date examples, making it straightforward to programmatically manage Compute Engine resources from Perl. It is newly released, documented with dual-transport examples, and distributed under the Apache 2.0 license.

Google::Cloud::Composer::V1 is a Perl client for the Google Cloud Composer V1 API that lets Perl programs manage Composer environments and resources via a high-performance gRPC transport. It integrates with Google::Auth for credentials and is auto-generated from the service Protocol Buffers so it closely mirrors the official API surface, making it a practical choice if you need to script or automate Composer operations from Perl. The distribution is Apache 2.0 licensed and the current generation includes improved documentation and examples showing both gRPC and alternate transport usage, reflecting a freshly regenerated client with separate service classes and other refinements. If you work with Google Cloud Composer and prefer using Perl for automation, this module gives you a maintained, protocol-aligned interface to the V1 API.

Google::Cloud::Build::V1 is a Perl client for the Google Cloud Build V1 API that lets Perl applications start and manage cloud build jobs, triggers, and related resources through a high-performance gRPC transport. It is an auto-generated interface derived from the Protocol Buffers schema and works with Google::Auth for authentication, so you can integrate Cloud Build operations directly into scripts or services with familiar Perl objects and methods. The module is Apache 2.0 licensed and the recent release focuses on generated service classes and improved documentation, including examples for different transport options.

Google::Cloud::Bigquery::V2 is an auto-generated Perl client for the Google BigQuery API that lets Perl programs call BigQuery RPCs over gRPC using Protocol Buffers. It exposes a wide set of methods for managing datasets, tables, jobs, models, routines, property graphs, row access policies, projects, and service accounts, with each RPC invoked by calling the corresponding method and passing request parameters as a Perl hash. Authentication is handled by supplying credentials such as a Google::Auth object when you create the client. This release is the initial auto-generated client (v0.03) and includes regenerated service classes, improved documentation and dual-transport examples to help you get started quickly.