semvec/pypi-packages huggingface dataset:
static-import-analysis 0.1.0a0
Static import analysis for Python projects: extract functions, classes, and imports by walking a project's AST.
Requires Python: >=2

# `static-import-analysis`

Static import analysis for Python projects: extract functions, classes, and imports by walking a project's AST.

## Features

- Find all modules in a Python source tree.
- Enumerate functions and classes (with parameter names) in every module.
- Discover all imports and `from ... import ...` statements, including their relative/absolute resolutions.
- Robust: does not import or execute code; works with broken modules (reported, but skipped).
- Correctly understands packages and `__init__.py`.

## Install

```sh
pip install static-import-analysis
```

## Usage

Python API example:

```python
from static_import_analysis import static_import_analysis

(
    module_name_to_absolute_python_file_path_dict,
    module_name_to_module_dict,
    module_name_to_function_name_to_parameter_name_list_dict,
    module_name_to_class_name_to_method_name_to_parameter_name_list_dict,
    module_name_to_import_tuple_set_dict,
    module_name_to_import_from_tuple_set_dict
) = static_import_analysis('/path/to/your/python/project')
```

- `module_name_to_absolute_python_file_path_dict` – maps each module's importable name to its `.py` file
- `module_name_to_module_dict` - module name -> ast.Module instance
- `module_name_to_function_name_to_parameter_name_list_dict` – module name -> function name -> parameter names
- `module_name_to_class_name_to_method_name_to_parameter_name_list_dict` – module name -> class name -> method name -> parameter names
- `module_name_to_import_tuple_set_dict` – module name -> set of (imported_module, alias) for all `import ...` statements
- `module_name_to_import_from_tuple_set_dict` – module name -> set of (imported_module, imported_name, alias) for all `from ... import ...` statements

## Example

Suppose directory structure:

```
project_root/
  - __init__.py
  - foo.py
  - bar/
    - __init__.py
    - baz.py
```

Result:

- `static_import_analysis('project_root')` will parse all these as modules `__init__`, `foo`, `bar`, `bar.baz` with correct import/parameter relationships.

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).
group-based-policy-automation 18.0.0
Group Based Policy Automation

===============================
group-based-policy-automation
===============================

Group Based Policy Automation

* Free software: Apache license
* Documentation: http://docs.openstack.org/developer/group-based-policy-automation
* Source: http://git.openstack.org/cgit/openstack/group-based-policy-automation
* Bugs: http://bugs.launchpad.net/group-based-policy-automation

Features
--------

* TODO
processcube-client 6.1.0
A Client for the workflow engine of the ProcessCube platform.
Keywords: workflow-engine atlas-engine client bpmn

# Client zur Anbindung des ProcessCube®

Der [ProcessCube®](https://www.5minds.de/processcube/) ist ein BPMN-Engine
der mittels [Python](http://processcube.io/docs/engine/clients/python/) 
angebunden werden kann. Die Beispiel sind unter [Developer-Seite](http://processcube.io/) 
zu finden.
group-based-policy 18.0.0
Openstack Group Based Policy

Group Based Policy (GBP) provides declarative abstractions for achieving
scalable intent-based infrastructure automation.

GBP complements the OpenStack networking model with the notion of policies
that can be applied between groups of network endpoints. As users look beyond
basic connectivity, richer network services with diverse implementations and
network properties are naturally expressed as policies. Examples include
service chaining, QoS, path properties, access control, etc.

GBP allows application administrators to express their networking requirements
using a Group and a Policy Rules-Set abstraction. The specifics of policy
rendering are left to the underlying pluggable policy driver.

GBP model also supports a redirect operation that makes it easy to abstract
and consume complex network service chains and graphs.

Checkout the GBP wiki page for more detailed information:
<https://wiki.openstack.org/wiki/GroupBasedPolicy>

The latest code is available at:
<http://git.openstack.org/cgit/openstack/group-based-policy>.

GBP project management (blueprints, bugs) is done via Launchpad:
<https://launchpad.net/group-based-policy>

For help using or hacking on GBP, you can send mail to
<mailto:openstack-dev@lists.openstack.org>.

Acronyms used in code for brevity:

- PT:  Policy Target
- PTG: Policy Target Group
- PR:  Policy Rule
- PRS: Policy Rule Set
- L2P: L2 Policy
- L3P: L3 Policy
- NSP: Network Service Policy
- EP: External Policy
- ES: External Segment
- SC: Service Chain
- SP: Service Profile
pysupercluster-problematy 0.7.8
A fast geospatial point clustering module (Problematy fork).
Requires Python: >=3

pysupercluster
==============

|tests|

.. |tests| image:: https://github.com/wemap/pysupercluster/workflows/tests/badge.svg
    :target: https://github.com/wemap/pysupercluster/actions

A fast Python 3 module for geospatial point clustering.

This is a port of https://github.com/mapbox/supercluster to C++, conveniently
wrapped in a Python module. Initial benchmarks show it to be an order of
magnitude (10x) faster than the original JavaScript implementation.

Installing pysupercluster
-------------------------

The easiest way to install pysupercluster is to use pip:

    pip install pysupercluster

Using pysupercluster
--------------------

.. code-block:: pycon

    >>> import numpy
    >>> import pysupercluster
    >>> points = numpy.array([
    ...     (2.3522, 48.8566),   # paris
    ...     (-0.1278, 51.5074),  # london
    ...     (-0.0077, 51.4826),  # greenwhich
    ... ])
    >>> index = pysupercluster.SuperCluster(
    ...     points,
    ...     min_zoom=0,
    ...     max_zoom=16,
    ...     radius=40,
    ...     extent=512)
    >>> clusters = index.getClusters(
    ...     top_left=(-180, 90),
    ...     bottom_right=(180, -90),
    ...     zoom=4)
    [
        {'id': 0, 'count': 1, 'expansion_zoom': None, 'latitude': 48.8566, 'longitude': 2.3522},
        {'id': 3, 'count': 2, 'expansion_zoom': 8, 'latitude': 51.49500168658321, 'longitude': -0.06774999999998421}
    ]
ilc-provider 0.1.3
Faker provider for ILC data models
Requires Python: >=3.12

### ilc-provider

![version](https://img.shields.io/badge/version-0.1.3-blue)
![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Ffourtreestech%2Filc-provider%2Fmain%2Fpyproject.toml)
![coverage](https://img.shields.io/badge/coverage-100%25-green)

**Faker provider for *ILC* data models**

Generates fake data for all data models: players, teams, leagues, etc.

When imported the *ilc_provider* package creates a 
[Faker](https://github.com/joke2k/faker/) instance
and adds itself as a provider. It can then be called
like any other provider:

    from ilc_provider import fake
    league = fake.league()

See the documentation for the full list of data that can be generated.

## Installation

    (.venv) $ pip install ilc-provider

## Usage

*ilc_provider* can be used as a [Pytest](https://docs.pytest.org/) fixture:

    # conftest.py

    import pytest
    from ilc_provider import fake

    # Any element of the provider can be accessed
    # from this fixture:
    # match = ilc_fake.match()
    @pytest.fixture(scope="session")
    def ilc_fake():
        return fake

    # A fake league is intensive to set up, so it is
    # usually best to make a session-scoped league fixture:
    @pytest.fixture(scope="session")
    def fake_league(ilc_fake):
        return ilc_fake.league()
click 8.3.1
Composable command line interface toolkit
Requires Python: >=3.10

<div align="center"><img src="https://raw.githubusercontent.com/pallets/click/refs/heads/stable/docs/_static/click-name.svg" alt="" height="150"></div>

# Click

Click is a Python package for creating beautiful command line interfaces
in a composable way with as little code as necessary. It's the "Command
Line Interface Creation Kit". It's highly configurable but comes with
sensible defaults out of the box.

It aims to make the process of writing command line tools quick and fun
while also preventing any frustration caused by the inability to
implement an intended CLI API.

Click in three points:

-   Arbitrary nesting of commands
-   Automatic help page generation
-   Supports lazy loading of subcommands at runtime


## A Simple Example

```python
import click

@click.command()
@click.option("--count", default=1, help="Number of greetings.")
@click.option("--name", prompt="Your name", help="The person to greet.")
def hello(count, name):
    """Simple program that greets NAME for a total of COUNT times."""
    for _ in range(count):
        click.echo(f"Hello, {name}!")

if __name__ == '__main__':
    hello()
```

```
$ python hello.py --count=3
Your name: Click
Hello, Click!
Hello, Click!
Hello, Click!
```


## Donate

The Pallets organization develops and supports Click and other popular
packages. In order to grow the community of contributors and users, and
allow the maintainers to devote more time to the projects, [please
donate today][].

[please donate today]: https://palletsprojects.com/donate

## Contributing

See our [detailed contributing documentation][contrib] for many ways to
contribute, including reporting issues, requesting features, asking or answering
questions, and making PRs.

[contrib]: https://palletsprojects.com/contributing/