PadWalker is a module which allows you to inspect (and even change!) lexical variables in any subroutine which called you. It will only show those variables which are in scope at the point of the call.

PadWalker is particularly useful for debugging. It's even used by Perl's built-in debugger. (It can also be used for evil, of course.)

I wouldn't recommend using PadWalker directly in production code, but it's your call. Some of the modules that use PadWalker internally are certainly safe for and useful in production.

Perl::Critic is an extensible framework for creating and applying coding
standards to Perl source code. Essentially, it is a static source code
analysis engine. Perl::Critic is distributed with a number of
Perl::Critic::Policy modules that attempt to enforce various coding
guidelines. Most Policy modules are based on Damian Conway's book Perl Best
Practices. However, Perl::Critic is not limited to PBP and will even
support Policies that contradict Conway. You can enable, disable, and
customize those Polices through the Perl::Critic interface. You can also
create new Policy modules that suit your own tastes.

For a command-line interface to Perl::Critic, see the documentation for
perlcritic. If you want to integrate Perl::Critic with your build
process, Test::Perl::Critic provides an interface that is suitable for
test programs. Also, Test::Perl::Critic::Progressive is useful for
gradually applying coding standards to legacy code. For the ultimate
convenience (at the expense of some flexibility) see the criticism
pragma.

Authors:
--------
Jeffrey Ryan Thalhammer

The purpose of PPI is not to parse Perl *Code*, but to parse Perl
*Documents*. By treating the problem this way, we are able to parse a
single file containing Perl source code "isolated" from any other
resources, such as libraries upon which the code may depend, and without
needing to run an instance of perl alongside or inside the parser.

Authors:
Adam Kennedy

This is a facility for creating non-modifiable variables. This is useful for configuration files, headers, etc. It can also be useful as a development and debugging tool, for catching updates to variables that should not be changed.

If any of the values you pass to Scalar, Array, or Hash are references, then those functions recurse over the data structures, marking everything as Readonly. Usually, this is what you want: the entire structure nonmodifiable. If you want only the top level to be Readonly, use the alternate Scalar1, Array1 and Hash1 functions.

String::Format lets you define arbitrary printf-like format sequences to be expanded. This module would be most useful in configuration files and reporting tools, where the results of a query need to be formatted in a particular way.

One recurring problem in modules that use Scalar::Util's weaken function is that it is not present in the pure-perl variant.
While this isn't necesarily always a problem in a straight CPAN-based Perl environment, some operating system distributions only include the pure-Perl versions, don't include the XS version, and so weaken is then "missing" from the platform, despite passing a dependency on Scalar::Util successfully.

Authors:
--------
Adam Kennedy

For many APIs with large numbers of classes, it can be very useful to be able to do a quick once-over to make sure that classes, methods, and inheritance is correct, before doing more comprehensive testing. This module aims to provide such a capability.

Perl's garbage collection has one big problem: Circular references can't get cleaned up. A circular reference can be as simple as two reference that refer to each other.

Test::Memory::Cycle is built on top of Devel::Cycle to give you an easy way to check for these circular references.

In situations where you have deep trees of classes, there is a common situation in which you test a module 4 or 5 subclasses down, which should follow the correct behaviour of not just the subclass, but of all the parent classes.

This should be done to ensure that the implementation of a subclass has not somehow "broken" the object's behaviour in a more general sense.

Test::Object is a testing package designed to allow you to easily test what you believe is a valid object against the expected behaviour of all of the classes in its inheritance tree in one single call.

To do this, you "register" tests (in the form of CODE or function references) with Test::Object, with each test associated with a particular class.

When you call object_ok in your test script, Test::Object will check the object against all registered tests. For each class that your object responds to $object->isa($class) for, the appropriate testing function will be called.

Doing it this way allows adapter objects and other things that respond to isa differently that the default to still be tested against the classes that it is advertising itself as correctly.

This also means that more than one test might be "counted" for each call to object_ok. You should account for this correctly in your expected test count.

There are a number of different situations (like testing caching code) where you want to want to do a number of tests, and then verify that some underlying subroutine deep within the code was called a specific number of times.

This module provides a number of functions for doing testing in this way in association with your normal Test::More (or similar) test scripts.

This framework is intended to support unit testing in an object-oriented development paradigm (with support for inheritance of tests etc.) and is derived from the JUnit testing framework for Java by Kent Beck and Erich Gamma.

This framework provides lighter version of Test::Unit framework. It implements some of the Test::Unit classes and methods needed to run test units. The Test::Unit::Lite tries to be compatible with public API of Test::Unit. It doesn't implement all classes and methods at 100% and only those necessary to run tests are available.

The Test::Unit::Lite can be distributed as a part of package distribution, so the package can be distributed without dependency on modules outside standard Perl distribution. The Test::Unit::Lite is provided as a single file.

This project provides generic python modules. The Python interpreter itself is developed at devel:languages:python:Factory.

If you happen to have collection of python packages send an email to opensuse-packaging to discuss wether it would not be better to provide them subproject within devel:languages:python namespace instead of storing them here.

The Python packaging policies are found at http://en.opensuse.org/openSUSE:Packaging_Python and https://en.opensuse.org/openSUSE:Packaging_Python_Singlespec

The project is focused on maintaining reasonable closeness to upstream
versions while at the same time trying to make packages available for openSUSE distribution.

The main focus is openSUSE Tumbleweed and packages that are not in there will be periodically pruned from the project.

Backporting of packages against older distribution releases should not be happening in this project, only build verification. If a package is needed on any of the older openSUSE products then maintenance update is to be created. Alternatively for SLE products submission by an interested party should be done by openSUSE:Backports project.
If you just need the newest packages, please consider using devel:languages:python:backports instead.

This is due to the size of this project and likeness of errors caused by adding this whole repository.

This package will be submitted to openSUSE:Factory soon. All changes for the Factory package should get tested here first.

This module parses the most common forms of ISO 8601 date strings (e.g. 2007-01-14T20:34:22+00:00) into datetime objects.

JMESPath (pronounced "jaymz path") allows you to declaratively specify how to extract elements from a JSON document.

For example, given this document:

{"foo": {"bar": "baz"}}

The jmespath expression foo.bar will return "baz".

JMESPath also supports:

Referencing elements in a list. Given the data:

{"foo": {"bar": ["one", "two"]}}

The expression: foo.bar[0] will return "one". You can also reference all the items in a list using the * syntax:

{"foo": {"bar": [{"name": "one"}, {"name": "two"}]}}

The expression: foo.bar[*].name will return ["one", "two"]. Negative indexing is also supported (-1 refers to the last element in the list). Given the data above, the expression foo.bar[-1].name will return ["two"].

The * can also be used for hash types:

{"foo": {"bar": {"name": "one"}, "baz": {"name": "two"}}}

The expression: foo.*.name will return ["one", "two"].

Paramiko is a module for python 2.2 (or higher) that implements the SSH2 protocol for secure (encrypted and authenticated) connections to remote machines.
Unlike SSL (aka TLS), the SSH2 protocol does not require hierarchical certificates signed by a powerful central authority. you may know SSH2 as the protocol that replaced telnet and rsh for secure access to remote shells, but the protocol also includes the ability to open arbitrary channels to remote services across the encrypted tunnel -- this is how sftp works, for example.
It is written entirely in python (no C or platform-dependent code) and is released under the GNU LGPL (lesser GPL).

Portpicker provides an API to find and return an available network port for an application to bind to. Ideally suited for use from unittests or for test harnesses that launch local servers.

Pytricia is a new python module to store IP prefixes in a patricia tree. It's based on Dave Plonka's modified patricia tree code, and has three things to recommend it over related modules (including py-radix and SubnetTree):

1. it's faster
2. it works in Python 3, and
3. there are a few nicer library features for manipulating the structure.

Decorator to support retry when an exception occurs.

This is a Python implementation of RFC6570, URI Template, and can expand templates up to and including Level 4 in that specification.

websocket-client module is WebSocket client for python. This provides the low level APIs for WebSocket. All APIs are synchronous functions.

websocket-client supports only hybi-13.