semvec/pypi-packages huggingface dataset:
BInject 0.0.2
Binject: inject shared object to apk
Requires Python: >=3.7

# Binject
inject shared object to an apk

## Install:

```bash
pip install binject 
```

## Usage:


```bash
usage: binject [-h] [--arch ARCH] <apk_path> <so_path>

Binject: inject shared object to apk

positional arguments:
  <apk_path>   path to target apk
  <so_path>    path to target so

options:
  -h, --help   show this help message and exit
  --arch ARCH  target architecture (default: arm64-v8a, options: armeabi-v7a, x86, etc)


```
netcenframe 0.0.6
Wrapper around NetCenLib that produces as output a sorted pandas DataFrame
Requires Python: >=3.9
Keywords: network, analysis, centrality

# Python package for the analysis of complex networks

Is it a fork? Is it a re-implementation?
I don't know!
What I do know is that this project uses for the implementations
the algorithms from the projects [NetCenLib](https://github.com/damianfraszczak/netcenlib) and [NetworkX](https://github.com/networkx/networkx).
This project also attempts to have the for NetworkX configurable
speed-up options pre-configured.

This project is for the most part an extension to NetCenLib
and therefore uses the same structure

The aim is to simplify the analysis step by returning an optionally
sorted and/or with the computed values re-scaled pandas DataFrame.

### Installation
```pip install netcenframe```

### parameters


### configuration
To configure the library, there is a `netcenframe.centrality.configure()` functionality
where settings can be passed to for the duration of the program's runtime
- sort: default is True
    - sorts the returned dataframe from highest to lowest centrality value
The default settings need to be applied with a call to `netcenframe.centrality.configure()`
 - They aren't automatically applied because some people would like to use their own parallel settings.



Calls to compute centralities looks like the examples below, in which the
graph measure betweenness centrality will be computed
via the library NetworkX and return a pandas DataFrame which is
already sorted. Before a dataframe is returned, the data is saved
as a file in CSV format for later usage, for example in other programs.



### Two ways of calling functionalities in the library
#### example usage with imports and configuration:
```python
# imports for netcenframe to make it easier to use
from netcenframe.centrality import compute_centrality as compute
from netcenframe.centrality import configure
from netcenframe.taxonomies.Centrality import BETWEENNESS, CLOSENESS, DEGREE

configure()
sorted_df = compute(/$graph, BETWEENNESS)
```

#### example without imports
```python
import netcenframe
# apply config:
netcenframe.centrality.configure()
# run centrality
sorted_df = netcenframe.centrality.compute_centrality(/$graph, netcenframe.taxonomies.Centrality.BETWEENNESS)
```
phonexia-transcription-normalization-client 2.0.1
Transcription Normalization Client
Requires Python: >=3.9
Keywords: grpc, stt, speech-to-text, text, transcription, normalization

![](https://www.phonexia.com/wp-content/uploads/phonexia-logo-transparent-500px.png)

# Phonexia Transcription Normalization client

This module contains client for communication with [transcription normalization microservice](https://hub.docker.com/repository/docker/phonexia/transcription-normalization/general) developed by [Phonexia](https://phonexia.com).

To use this client you will first need a running instance of any *Phonexia transcription normalization microservice*. If you don't yet have any running instance, don't hesitate to [contact our sales department](mailto:info@phonexia.com).

You can learn more about the transcription normalization technology [here](https://docs.phonexia.com/products/speech-platform-4/technologies/transcription-normalization/).

On [this page](https://docs.phonexia.com/products/speech-platform-4/grpc/api/phonexia/grpc/technologies/transcription_normalization/v1/transcription_normalization.proto), you will find a *gRPC API* reference for *transcription normalization microservice*.
fast-gov-uk 0.9.1
A toolkit for rapid development of simple gov.uk services
Requires Python: >=3.12

# fast-gov-uk

Fast-gov-uk is a new toolkit for **rapid development of simple gov.uk services**.

Fast-gov-uk is three things -

1) an implementation of [gov.uk design system](https://design-system.service.gov.uk) in Python using [FastHTML](https://www.fastht.ml)
2) lightweight scaffolding for common service patterns e.g. forms
3) designed from the ground-up for AI agents to help with rapid development


## Installation

```
$ pip install fast-gov-uk
```


## A Simple Example

```python
# save this as app.py
from fast_gov_uk import Fast, serve
from fast_gov_uk import design_system as ds

fast = Fast()

@fast.page("/")
def get_started():
    return ds.Page(
        ds.Warning("This is a demo and not a real service"),
        ds.H1("Welcome to the service"),
        ds.P("You will need the following information handy:"),
        ds.Ul(
            ds.Li("NI Number"),
            ds.Li("Date of birth"),
            ds.Li("Email"),
            bullet=True,
        ),
        ds.StartButton("I am ready", "/forms/"),
    )

serve(app="fast")
```

```
$ python app.py
```

Point your browser to: `http://localhost:5001` -

![Screenshot of the simple example](https://raw.githubusercontent.com/alixedi/fast-gov-uk/refs/heads/main/docs/_static/start.png)


## Resources

* [Documentation](https://fast-gov-uk.readthedocs.io/en/latest/)
rpi-app-framework 0.1.3
A Python framework for building applications on all Raspberry Pi versions, including Pico.
Requires Python: >=3.6
Keywords: raspberry-pi, pico, framework, app-development, iot

RPi App Framework
Modular framework for all Raspberry Pi models (Pico 2 W with MicroPython/Thonny, full RPi 1-5 with Python).
Installation
For MicroPython/Pico (Thonny):

Copy the rpi_app_framework folder to /lib on your Pico.

For full Python/RPi:

pip install rpi-app-framework

Usage
Create a main.py to start your app:
# examples/simple_demo.py
from rpi_app_framework import RPIApp, PiHardwareAdapter
import time

class SimpleDemo(RPIApp):
    """
    Minimal demo that shows:
      • Board model detection
      • CPU temperature monitoring
      • On-board LED blinking
    Works on Pico 2 W and all full-size Raspberry Pi models.
    """

    def setup(self):
        # Initialise the hardware adapter
        self.hw = PiHardwareAdapter(log_func=self.log)

        # Use the onboard LED (works on Pico and full RPi)
        self.status_led = self.hw.led("LED" if "Pico" in self.hw.model else 13)

        # Log startup info
        self.log(f"Running on: {self.hw.model}")
        self.log(f"Initial CPU temperature: {self.hw.cpu_temperature}°C")

    def run(self):
        while self.running:
            # Blink the LED
            self.status_led.value(1)
            time.sleep(0.5)
            self.status_led.value(0)

            # Log temperature every 5 seconds
            self.log(f"CPU temperature: {self.hw.cpu_temp}°C")
            time.sleep(4.5)

if __name__ == "__main__":
    SimpleDemo(max_log_files=10).start()

Compatibility

Pico 2 W (MicroPython): Uses machine for pins/PWM.
Full RPi (Python): Uses RPi.GPIO and gpiozero for pins/PWM.

Features

RPIApp: Base class for app lifecycle and logging.
DeviceManager: Base for hardware managers with logging.
LEDSimple: Controls LEDs (on/off/blink).
WiFiManager: Manages WiFi connections (Pico only).
MotorDriverTB6612FNG: Controls dual DC motors.
MicrodotManager: Runs a lightweight web server.

For example applications see projects at www.singerlinks.com
open-data-contract-standard 3.1.2
The Pydantic Model of the Open Data Contract Standard
Requires Python: >=3.10

# Open Data Contract Standard (Python)

The pip module `open-data-contract-standard` to read and write YAML files using the [Open Data Contract Standard](https://github.com/bitol-io/open-data-contract-standard). The pip module was extracted from the [Data Contract CLI](https://github.com/datacontract/datacontract-cli), which is its primary user.

The version number of the pip module corresponds to the version of the Open Data Contract Standard it supports.

## Version Mapping

| Open Data Contract Standard Version | Pip Module Version |
|-------------------------------------|--------------------|
| 3.0.1                               | >=3.0.1            |
| 3.0.2                               | >=3.0.4            |
| 3.1.0                               | >=3.1.0            |

**Note**: We mirror major and minor version from the ODCS to the pip module, but not the patch version!

## Installation

```bash
pip install open-data-contract-standard
```

## Usage

```python
from open_data_contract_standard.model import OpenDataContractStandard

# Load a data contract specification from a file
data_contract = OpenDataContractStandard.from_file('path/to/your/data_contract.yaml')
# Print the data contract specification as a YAML string
print(data_contract.to_yaml())
```

```python
from open_data_contract_standard.model import OpenDataContractStandard

# Load a data contract specification from a string
data_contract_str = """
version: 1.0.0
kind: DataContract
id: 53581432-6c55-4ba2-a65f-72344a91553b
status: active
name: my_table
apiVersion: v3.1.0
"""
data_contract = OpenDataContractStandard.from_string(data_contract_str)
# Print the data contract specification as a YAML string
print(data_contract.to_yaml())
```


## Development

```
uv sync --all-extras
```

## Release

- Change version number in `pyproject.toml`
- Run `./release` in your command line
- Wait for the releases on [GitHub](https://github.com/datacontract/open-data-contract-standard-python/releases), [PyPi](https://test.pypi.org/project/open-data-contract-standard/) and [PyPi (test)](https://test.pypi.org/project/open-data-contract-standard/)
pytest-ampel-core 0.10.0a7
A plugin to provide AmpelContext fixtures in pytest
Requires Python: <4,>=3.10

=================
pytest-ampel-core
=================

.. image:: https://img.shields.io/pypi/v/pytest-ampel-core.svg
    :target: https://pypi.org/project/pytest-ampel-core
    :alt: PyPI version

.. image:: https://img.shields.io/pypi/pyversions/pytest-ampel-core.svg
    :target: https://pypi.org/project/pytest-ampel-core
    :alt: Python versions

.. image:: https://github.com/jvansanten/pytest-ampel-core/actions/workflows/main.yml/badge.svg
    :target: https://github.com/jvansanten/pytest-ampel-core/actions/workflows/main.yml
    :alt: See Build Status on GitHub Actions

A plugin to provide AmpelContext fixtures in pytest

----

This `pytest`_ plugin was generated with `Cookiecutter`_ along with `@hackebrot`_'s `cookiecutter-pytest-plugin`_ template.


Features
--------

* TODO


Requirements
------------

* TODO


Installation
------------

You can install "pytest-ampel-core" via `pip`_ from `PyPI`_::

    $ pip install pytest-ampel-core


Usage
-----

* TODO

Contributing
------------
Contributions are very welcome. Tests can be run with `tox`_, please ensure
the coverage at least stays the same before you submit a pull request.

License
-------

Distributed under the terms of the `BSD-3`_ license, "pytest-ampel-core" is free and open source software


Issues
------

If you encounter any problems, please `file an issue`_ along with a detailed description.

.. _`Cookiecutter`: https://github.com/audreyr/cookiecutter
.. _`@hackebrot`: https://github.com/hackebrot
.. _`MIT`: https://opensource.org/licenses/MIT
.. _`BSD-3`: https://opensource.org/licenses/BSD-3-Clause
.. _`GNU GPL v3.0`: https://www.gnu.org/licenses/gpl-3.0.txt
.. _`Apache Software License 2.0`: https://www.apache.org/licenses/LICENSE-2.0
.. _`cookiecutter-pytest-plugin`: https://github.com/pytest-dev/cookiecutter-pytest-plugin
.. _`file an issue`: https://github.com/jvansanten/pytest-ampel-core/issues
.. _`pytest`: https://github.com/pytest-dev/pytest
.. _`tox`: https://tox.readthedocs.io/en/latest/
.. _`pip`: https://pypi.org/project/pip/
.. _`PyPI`: https://pypi.org/project
flask-marshmallow-openapi 0.7.0
Flask + marshmallow + OpenAPI
Requires Python: >=3.11
Keywords: OpenAPI SwaggerUI ReDoc

# Overview

[![PyPI Status](https://badge.fury.io/py/flask-marshmallow-openapi.svg)](https://badge.fury.io/py/flask-marshmallow-openapi)
[![license](https://img.shields.io/pypi/l/flask-marshmallow-openapi.svg)](https://opensource.org/licenses/MIT)
[![python_versions](https://img.shields.io/pypi/pyversions/flask-marshmallow-openapi.svg)](https://pypi.org/project/flask-marshmallow-openapi/)
[![documentation](https://readthedocs.org/projects/flask-marshmallow-openapi/badge/?version=latest)](https://flask-marshmallow-openapi.readthedocs.io/en/latest/?badge=latest)


Provides OpenAPI documentation generated from code for
[Flask](https://flask.palletsprojects.com/en/latest/) APIs built around
[marshmallow](https://marshmallow.readthedocs.io/en/stable/) schemas.

This hackish and organically grown ™ package was created because no other similar
projects worked exactly the way I wanted them.

Similar projects:

- [flasgger](https://github.com/flasgger/flasgger)
- [flask-openapi3](https://github.com/luolingchun/flask-openapi3)

## Installation

~~~sh
pip install flask-marshmallow-openapi
~~~

## Documentation

[Read the Docs](https://flask-marshmallow-openapi.readthedocs.io/en/latest)

## What does it do?

Searches your codebase for [marshmallow](https://marshmallow.readthedocs.io/en/stable/)
schemas and 🎖️ decorated 🎖️ Flask routes.

It then produces `swagger.json` and injects it into self-hosted
[ReDoc](https://github.com/Redocly/redoc) and
[SwaggerUI](https://github.com/swagger-api/swagger-ui) documentation viewers.

```py
api = flask.Blueprint("my_api", __name__)


class BookSchema(ma.Schema):
    id = ma.fields.Integer(as_string=True)
    title = ma.fields.String(allow_none=False)
    publisher = ma.fields.String(allow_none=False)
    isbn = ma.fields.String(allow_none=False)


@open_api.get_list(BookSchema)
@api.route("/books", methods=["GET"])
def books_list():
    return "<p>Hello, World!</p>"


app = flask.Flask(__name__)
app.register_blueprint(api, url_prefix="/v1")


conf = OpenAPISettings(
    api_version="v1", api_name="My API", app_package_name="my_api", mounted_at="/v1"
)
docs = OpenAPI(config=conf)
docs.init_app(app)
```

New app routes:

```sh
$ flask routes

Endpoint               Methods  Rule
---------------------  -------  -------------------------------
# ...
open_api.re_doc        GET      /v1/docs/re_doc
open_api.static        GET      /v1/docs/static/<path:filename>
open_api.swagger_json  GET      /v1/docs/static/swagger.json
open_api.swagger_ui    GET      /v1/docs/swagger_ui
open_api.swagger_yaml  GET      /v1/docs/static/swagger.yaml
# ...
```