semvec/pypi-packages huggingface dataset:
kneo-joblet 0.1.0
KNeo Serverless Job
Requires Python: >=3.10

# EOCube Functions

EOCube functions is a fork of the [KNeo Joblet Function](https://gitlab.terrasigna.com/kneo/kneo-joblet) project.

EOCube Functions aims to be a simple runtime for invoking serverless KNative functions. 
It handles:
- HTTP Based functions: handling liveness, routing and CloudEvent extraction
- Batch Jobs: integration with the KNative JobSink
- Authentication using OIDC for Broker interaction

The base (kneo-functions) library is inspired by `parliament-functions` and aims to be a dropin replacement.


Developers only need to write a function which takes a `Context` object as a sole parameter.

## 🙏 Acknowledgements

This work is funded by a grant of the  European Space Angency. Project KNeo.

This work is partially supported by a grant of the Ministry of Research, Innovation and Digitization, 
CCCDI - UEFISCDI, project number **PN-IV-P6-6.3-SOL-2024-2-0248**, within PNCDI IV.
limitlion 1.1.0
Close LimitLion
Requires Python: >=3.10


[![Test](https://github.com/closeio/limitlion/actions/workflows/test.yml/badge.svg)](https://github.com/closeio/limitlion/actions/workflows/test.yml)
# LimitLion

A token bucket rate limiting throttle using Redis as the backend. Inspired by
Stripe's [Scaling your API with rate limiters](https://stripe.com/blog/rate-limiters)
blog post.  Can be used to control processing rates from one to many processes.
Potential implementations include protecting databases from high processing rates,
orchestrating queue consumer processes, or enforcing HTTP request rate limits.

Install with: `pip install limitlion`

Following is a simple example of a throttle named `test` that allows `5` requests per second (RPS) with
a burst factor of `2` using a `8` second window and requesting `1` token (default)
for each unit of work.  Look in the `examples` directory for more.

```py
redis = redis.Redis('localhost', 6379)
throttle_configure(redis)
while True:
    allowed, tokens, sleep = throttle('test', 5, 2, 8)
    if allowed:
        print ('Do work here')
    else:
        print ('Sleeping {}'.format(sleep))
        time.sleep(sleep)
```

## Design
The rate limiting logic uses a classic token bucket algorithm but is implemented
entirely as a Lua Redis script.  It leverages the Redis [TIME](https://redis.io/commands/time)
command which ensures fair microsecond resolution across all callers independent
of the caller's clock.  Note that buckets start and end on whole seconds.

Redis 3.2+ is required because `replicate_commands()` is used to support using
the `TIME` command in a Lua script.

## Configuring
Default values for RPS, burst factor and window size are supplied to the throttle
Lua script.  The Lua script creates a `throttle:[throttle name]:knobs` hash with
these values if it does not yet exist in Redis.  The script then uses the values
in that `knobs` hash for the token bucket calculations.  Each call also sets the
TTL for the `knobs` key to 7 days so it will remain in Redis as long as the
throttle has been active in the last week.

Since these settings are stored in Redis a separate process can be used to adjust
them on the fly.  This could simply be manually issuing the Redis command to
change the RPS or a more sophisicated process that polls Prometheus metrics to
determine the current load on your database and adjust the RPS accordingly.

# Running Counter
Another small but useful tool to keep track of counts in Redis for specified
time windows. These counts can then be used to make decisions on limiting or
 failing processes as well as for diagnostics. Checkout [`running_counter.py
`](limitlion/running_counter.py) for details.
odoo-simple-api-wrapper 0.1.0
A simple and clean Python api wrapper for Odoo XML-RPC API
Requires Python: >=3.6

# Odoo Simple Api Wrapper

A clean and lightweight Python connector for **Odoo's XML-RPC API**.

This package simplifies interactions with Odoo models using Python, so you can authenticate, read, create, update, and delete records easily.

## ✨ Features

- 🔐 Authentication via XML-RPC
- 📚 CRUD operations on any Odoo model
- 🔁 Generic method caller
- 🧼 Clean and well-documented code
- ✅ Ready for use in production or automation scripts

---

## 🛠️ Installation

### A. Clone the repository & install locally:

```bash
git clone https://github.com/your-user/odoo_connector.git
cd odoo_connector
pip install -e .
```

---

## 🚀 Usage

### 1. Import and initialize

```python
from odoo_simple_api_wrapper import OdooConnector

odoo = OdooConnector(
    url='https://your-odoo-instance.com',
    db='your_database_name',
    username='admin@example.com',
    password='your_password'
)
```

### 2. Read records

```python
partners = odoo.read('res.partner', fields=['name', 'email'], limit=5)
for p in partners:
    print(p)
```

### 3. Create a record

```python
partner_id = odoo.create('res.partner', {
    'name': 'Bruce Wayne',
    'email': 'batman@gotham.com'
})
print("New Partner ID:", partner_id)
```

### 4. Update a record

```python
odoo.write('res.partner', [partner_id], {'phone': '+123456789'})
```

### 5. Delete a record

```python
odoo.unlink('res.partner', [partner_id])
```

### 6. Call a custom method

```python
has_rights = odoo.call_method(
    'res.partner',
    'check_access_rights',
    ['read'],
    {'raise_exception': False}
)
print("Has read access:", has_rights)
```

---

## 📦 Project Structure

```
odoo_connector/
├── odoo_connector/
│   ├── __init__.py
│   └── api.py
├── tests/
│   └── test_connector.py
├── setup.py
├── README.md
└── LICENSE
```
neuronbridge-python 3.3.0
Python API for NeuronBridge
Requires Python: >=3.9
Keywords: neuroscience, neuron, similarity, search, api

# NeuronBridge Python API

[![DOI](https://zenodo.org/badge/479832149.svg)](https://zenodo.org/badge/latestdoi/479832149)

A Python API for the [NeuronBridge](https://github.com/JaneliaSciComp/neuronbridge) neuron similarity search service.

![Data Model Diagram](model_diagram.png)

## Installation

This library is available [on PyPI](https://pypi.org/project/neuronbridge-python/), so you can install it like this:

```bash
pip install neuronbridge-python
```

## Usage

The client will automatically select the latest version of the data and fetch it from S3. Here's a simple example of how to get an EM image by id:

```python
from neuronbridge import client
client = client.Client()
em_image = client.get_em_image(636798093) 
```

See [this notebook](https://github.com/JaneliaSciComp/neuronbridge-python/blob/main/notebooks/python_api_examples.ipynb) for complete usage examples.

## Development Notes

To build this code you will need to [install UV](https://docs.astral.sh/uv/getting-started/installation/).

Create a new UV virtual environment and install the dependencies:

```bash
uv venv --python 3.11
source .venv/bin/activate
uv pip sync requirements-universal.txt
uv pip install -e .
```

### Running data validation using Ray

You can run validation multithreaded on a single machine like this:

```bash
./neuronbridge/validate_ray.py --dashboard --cores 60
```

To run the validation script in a distributed manner on the Janelia cluster, you must first install [ray-janelia](https://github.com/JaneliaSciComp/ray-janelia) in a sister directory to where this code base is cloned. Then run a script to bsub the Ray cluster:

```bash
./scripts/launch_validation.sh
```

### Updating requirements

After updating the requirements.txt file, you can sync the requirements-universal.txt file like this:

```bash
uv pip compile requirements.txt --universal --output-file  requirements-universal.txt
```

### Regenerate the JSON schemas:

```bash
python neuronbridge/generate_schemas.py
```

### Run the unit tests:

```bash
pixi run test
```

### Publishing a new release

1) Update the version in setup.py
2) Push all changes and tag a release in GitHub
3) Build PyPI distribution:

```bash
pixi run pypi-build
```

4) Upload to PyPI:

```bash
pixi run pypi-upload
```
qt-material-ui 0.5.1
Material 3 component library for Qt Widgets
Requires Python: >=3.10
Keywords: components, material, qt, ui, widgets

# Qt Material UI

[![PyPI - Version](https://img.shields.io/pypi/v/qt-material-ui?logo=python&logoColor=%23ccc)](https://pypi.org/project/qt-material-ui/)
[![Tests](https://img.shields.io/github/actions/workflow/status/herobank110/qt-material-ui/tests.yml?logo=github&label=tests&logoColor=%23ccc)](https://github.com/herobank110/qt-material-ui/actions/workflows/tests.yml)
[![codecov](https://codecov.io/github/herobank110/qt-material-ui/graph/badge.svg?token=OF1WOOAZ6U)](https://codecov.io/github/herobank110/qt-material-ui)
[![Read the Docs](https://img.shields.io/readthedocs/qt-material-ui?logo=readthedocs)](https://qt-material-ui.readthedocs.io/en/latest)
![License](https://img.shields.io/pypi/l/qt-material-ui.svg)

Material 3 component library for Qt Widgets

## Features

- Modern UI building blocks
- Visual effects (ripples, elevations, transitions)
- Runtime dynamic theming support
- Type annotations and PEP8 conventions
- Documentation with previews and usage examples

## Get Started

This library is available on PyPI and can be installed with pip:

```bash
pip install qt-material-ui
```

[Continue to documentation](https://qt-material-ui.readthedocs.io/en/latest/get-started/development-status.html)

## Development Status

The library is currently in beta status and under active development.

Not all components have been implemented, and some APIs may change in
future releases.