semvec/pypi-packages huggingface dataset:
how-to-sea-GRPC-bindings 0.0.1
A internal project to easily access the GRPC bindings for the How to Sea project
Requires Python: >=3.8

## Python implementation
You will need the following 
```
grpcio~=1.66
grpcio-tools~=1.66
```

Generate the python bindings with
```bash
python -m grpc_tools.protoc -I./proto --python_out=./proto --pyi_out=./proto --grpc_python_out=./proto ./proto/<filename>.proto
```
verify-project-demo-96f746e1 0.1.1
A sample Python package that generates test code.
Requires Python: >=3.6

# verify-project-demo-96f746e1

    This is a sample Python package that generates test code with specified comments.

    ## Installation

    Install the package with:

    ```sh
    pip install verify-project-demo-96f746e1
    from my_package.code_generator import generate_test_code

    directory = 'test'
    filename = 'test_code.py'
    custom_value = 'specified_value'
    generate_test_code(directory, filename, custom_value)
smartheattable 0.0.2
Smart heat table software in Python
Requires Python: >=3.11

smartheattable
==============

|PyPI| |Documentation Status| |PyPI - License|

A Python package for modelling a district heating network. 
The code is being developed for the AEA-BES research group at HAN University of Applied Sciences, The Netherlands. 
The **smartheattable** package can be used under the conditions of the GPLv3 license.

Features
--------

* Layout and operation of a district heating network.


Installation
------------

To use the package `smartheattable`, install it in a Python environment:

.. code-block:: console

    (env) pip install smartheattable

or

.. code-block:: console

    (env) conda install smartheattable

This should
automatically install the dependency packages ``matplotlib`` , ``scipy``
and ``pandas``, if they haven't been installed already. If you are
installing by hand, ensure that these packages are installed as well.

Example use
-----------

.. code:: python

   python -m smartheattable


smartheattable pages
--------------------

-  `PyPi <https://pypi.org/project/smartheattable/>`__: smartheattable Python package
-  `BitBucket <https://bitbucket.org/deltares/smartheattable/>`__: smartheattable source code
-  `ReadTheDocs <https://smartheattable.readthedocs.io/>`__: smartheattable documentation

Author and license
------------------

-  Author: Paul van Kan, Maarten van den Berg, Ronald van Buuren
-  Contact: paul.vankan@han.nl
-  License: `GPLv3 <https://www.gnu.org/licenses/gpl.html>`__

References
----------

-  ...

.. |PyPi| image:: https://img.shields.io/pypi/v/smartheattable
   :alt: PyPI

.. |PyPI - Downloads| image:: https://img.shields.io/pypi/dm/smartheattable
   :alt: PyPI - Downloads

.. |PyPi Status| image:: https://img.shields.io/pypi/status/smartheattable
   :alt: PyPI - Status

.. |Documentation Status| image:: https://readthedocs.org/projects/smartheattable/badge/?version=latest
   :target: https://edumud.readthedocs.io/en/latest/?badge=latest

.. |PyPI - License| image:: https://img.shields.io/pypi/l/smartheattable
   :alt: PyPI - License
django-js-lib-htmx 2.0.3.1
HTMX Repackaged for Django

# HTMX Repackaged for Django

[HTMX](https://htmx.org/) packaged in a Django reusable app.


## Installation

    pip install django-js-lib-htmx

## Usage

1. Add `"js_lib_htmx"` to your `INSTALLED_APPS` setting like this::

       INSTALLED_APPS = [
           ...
           "js_lib_htmx",
           ...
       ]

2. In your template use:
   
       {% load static %}
   
      And one of:
    
       <script src="{% static "htmx/htmx.js" %}"></script>
       <script src="{% static "htmx/htmx.min.js" %}"></script>
sahi-processor 0.0.4
Using SAHI as a pre and post processing step
Requires Python: >=3.8

# SAHI_processor
Using SAHI as a pre and post processing step

Link to original repo, [SAHI: Slicing Aided Hyper Inference](https://github.com/obss/sahi)

## Impetus
To make it easier to use sahi without changes to the your model inference code. Also allow for batched inference which is something that is not provided in the official repo.

## How to use
Install package with 
```
pip install sahi_processor
```

Sample usage
```
from sahi_processor.sahi_processor import SAHIProcessor

processor = SAHIProcessor()
batched_images = processor.get_slice_batches(list_of_images, model_batchsize=batchsize)

# run batched_images through your model and output predictions
# combine all batches of predictions into  List[List[l, t, r, b, score, class_id]]

merged_predictions = processor.run_sahi_algo(list_of_images, predictions)
```

A sample test script can be ran via `python tests/test.py`

## Parameters and defaults for SAHIProcesor

```
# image_height_threshold: int
#     only do sahi if the height of the image exceeds this
# image_width_threshold: int
#     only do sahi if the width of the image exceeds this
#     The rationale for these 2 parameters is that since this repo is meant to batch multiple images,
#     there could be a case where we have images of different size in a batch. For image that may be
#     around the size of a single slice, there may not be a point to slice them
# resize_full_frame: bool
#     to resize images that has not been sliced size to the slice size if True else no resizing

image_height_threshold: int = 600 
image_width_threshold: int = 600
resize_full_frame: bool = True

# the variables below are from the default sahi repo: https://github.com/obss/sahi/blob/main/sahi/predict.py#L125
sahi_slice_height: int = 400
sahi_slice_width: int = 400
sahi_overlap_height_ratio: float = 0.3
sahi_overlap_width_ratio: float = 0.3
sahi_perform_standard_pred: bool = True
sahi_postprocess_type: str = "GREEDYNMM"
sahi_postprocess_match_metric: str = "IOS"
sahi_postprocess_match_threshold: float = 0.5
sahi_postprocess_class_agnostic: bool = True
sahi_auto_slice_resolution: bool = True
```

## Formats to note
`list_of_images` is a list of cv2 images in `(H, W, C)`

`predictions` is a list of predictions for each image.
Below is a sample:
```
[
    [ 
        [l, t, r, b, score, class_id],
        [l, t, r, b, score, class_id], ...
    ],...
]
```
python-readiness 2.2
Are your dependencies ready for new Python?
Requires Python: >=3.9

# python_readiness

Are your dependencies ready for new Python?

## Installation

```bash
pip install python_readiness
```

Alternatives include:
- `uvx python_readiness`
- It's a single file script that contains PEP 723 metadata

## Usage

**Check if a specific package is ready for a specific Python:**
```bash
python_readiness -p numpy --python 3.11
```

This will print the requirement you need to ensure that numpy supports that Python:
```bash
λ python_readiness -p numpy --python 3.13
numpy>=2.1.0      # has_classifier_and_explicit_wheel
λ python_readiness -p numpy --python 3.12
numpy>=1.26.0     # has_classifier_and_explicit_wheel
λ python_readiness -p numpy --python 3.11
numpy>=1.23.3     # has_classifier_and_explicit_wheel
λ python_readiness -p 'numpy>=2' --python 3.11
numpy>=2          # has_classifier_and_explicit_wheel (existing requirement ensures support)
```

**Check if a requirements file is ready for a specific Python:**
```bash
python_readiness -r requirements.txt --python 3.13
```

This will output new requirements that ensure your environment is restricted to versions that
will support the specified Python version. In particular, look at lines containing "previously".
These are the minimum versions you will need to upgrade to for support.

I find this really useful for updating constraints files when incrementally upgrading a large
codebase to a new Python.

**Check if your current environment is ready for the latest Python:**
```bash
python_readiness
```

**Check if another virtual environment is ready for the latest Python:**
```bash
python_readiness -e path/to/.venv
```

**See all options:**
```bash
python_readiness --help
```

## What are the exact definitions of readiness this uses?

Take a look at the code, in particular `support_from_files`.

It's primarily based on wheel tags and classifiers, but looks at some other metadata and has a
few interesting tricks.

`python_readiness` currently classifies package versions as one of the following levels of support:

Explicitly supported:
- `has_classifier_and_explicit_wheel`\
  Both `has_classifier` and `has_explicit_wheel` are true.
- `has_classifier`\
  Has a trove classifier for the corresponding Python version.
- `has_explicit_wheel`\
  Has a wheel that specifically supports the corresponding Python version (includes abi3 wheels targeting specifically that Python)
- `is_requires_python_lower_bound`\
  Niche, but if `Requires-Python: >=3.9` then the package explicitly supports 3.9.

Potentially supported:
- `has_viable_wheel`\
  Has a wheel that is installable on the Python version, but has no explicit indication that upstream has ever run it with that Python version.
- `totally_unknown`\
  This is usually because the package only provides an sdist.

Unsupported:
- `unsupported`

Also, if you're interested in looking at the code — the bisection code we use to find earliest
supported versions is interesting, since it can handle non-monotonic support, e.g. in the case of
backports.
HuiFontMap 0.1.0
A tool library for generating mapping dictionaries based on font files
Requires Python: >=3.6

Project description
⭐️ **简介**
本库是一个基于 python 的工具集，用于生成字体文件字典映射。


✨️ **理念**
简单，可靠，省心。

📕 **背景**
进行数据采集的时候，常常会遇到字体反爬，常用的解决办法是通过获取字体字形映射关系替换文本解决，但生成或者说是获取字体映射关系的方法不是很常见，所以写了这个库，方便生成获取

🌠 **用法**
这里介绍工具用法。
## 安装
```python
pip install HuiFontMap
```
## 使用

```python
在这里插入代码片
```
invisibl-aether-sdk 0.1.0
The Python SDK for Invisibl's Aether platform.
Requires Python: <4.0.0,>=3.9.12

# aether-sdk
Aether's user-facing package (SDK, CLI, etc.)

## SDK Authentication
There are two options for authentication. In order of precedence, they are:
1. set the environment variables `AETHER_USER_ID` and `AETHER_API_KEY`; or
2. run `Auth.setup()`.

### Set the ENVs
If these two environment variables are set, they are given preference over any profile set in the shared credentials file.

### Run `Auth.setup()`
This will create a shared credentials file in `~/.aether/credentials` (or at the path from the environment variable `AETHER_SHARED_CREDENTIALS_FILE`, if present). It will set up a profile with the name you provide, setting the API key and user ID there.

If you set a profile with a name different from `default`, set the environment variable `AETHER_PROFILE` before running the SDK.
arnold-bhadauria 0.1.0
A simple package to calculate area and perimeter of 2d shapes.
Requires Python: >=3.6

# Arnold Package

This Python project provides classes to represent and calculate properties for various geometric shapes: Square, Rectangle, Circle, and Triangle. Each class supports methods to calculate the area and perimeter.

## Classes

### Square

- **Constructor**: `Square(length: float)`
    - **Parameters**:
        - `length`: Length of the square's side (positive integer or float).
  
- **Methods**:
    - `area()`: Returns the area of the square.
    - `perimeter()`: Returns the perimeter of the square.

### Rectangle

- **Constructor**: `Rectangle(width: float, height: float)`
    - **Parameters**:
        - `width`: Width of the rectangle (positive integer or float).
        - `height`: Height of the rectangle (positive integer or float).

- **Methods**:
    - `area()`: Returns the area of the rectangle.
    - `perimeter()`: Returns the perimeter of the rectangle.

### Circle

- **Constructor**: `Circle(radius: float)`
    - **Parameters**:
        - `radius`: Radius of the circle (positive integer or float).

- **Methods**:
    - `area()`: Returns the area of the circle.
    - `perimeter()`: Returns the circumference of the circle.

### Triangle

- **Constructor**: `Triangle(base: float = None, height: float = None, side1: float = None, side2: float = None, side3: float = None)`
    - **Parameters**:
        - `base`: Base of the triangle (positive integer or float).
        - `height`: Height of the triangle (positive integer or float).
        - `side1`: Length of the first side (positive integer or float).
        - `side2`: Length of the second side (positive integer or float).
        - `side3`: Length of the third side (positive integer or float).

- **Methods**:
    - `area()`: Returns the area of the triangle (uses either base and height or all three sides).
    - `perimeter()`: Returns the perimeter of the triangle.

## Usage Example

Hereâ€™s a simple example of how to use the classes:

```python
from arnold import Square, Rectangle, Circle, Triangle

# Create a Square object
square = Square(4)
print(f"Square Area: {square.area()}")
print(f"Square Perimeter: {square.perimeter()}")

# Create a Rectangle object
rectangle = Rectangle(3, 5)
print(f"Rectangle Area: {rectangle.area()}")
print(f"Rectangle Perimeter: {rectangle.perimeter()}")

# Create a Circle object
circle = Circle(2)
print(f"Circle Area: {circle.area()}")
print(f"Circle Perimeter: {circle.perimeter()}")

# Create a Triangle object
triangle = Triangle(base=3, height=4, side1=3, side2=4, side3=5)
print(f"Triangle Area: {triangle.area()}")
print(f"Triangle Perimeter: {triangle.perimeter()}")
berryimu 0.0.1
C++ bindings for controlling the BerryIMU
Requires Python: >=3.9

# berryimu

This is a Python package with bindings for interacting with the BerryIMU.

## Wiring

The BerryIMU is a 9-axis motion tracking device that can be connected to a Raspberry Pi via I2C. The following wiring is required:

- BerryIMU VCC to 3.3V
- BerryIMU GND to GND
- BerryIMU SCL to SCL
- BerryIMU SDA to SDA

See the example wiring diagrams [here](https://ozzmaker.com/product/berryimu-accelerometer-gyroscope-magnetometer-barometricaltitude-sensor/).

## Installation

Install the package from PyPI:

```bash
pip install berryimu
```

To verify the installation, run:

```bash
berryimu
```

You should see the BerryIMU data printed to the console.
ocbc-dbs-statement-parser 0.2.1
A tool to parse OCBC and DBS bank and credit card statements from PDF files
Requires Python: <3.9,>=3.7

# OCBC DBS Statement Parser

A Python tool to parse bank statements from PDF files, specifically designed for OCBC and DBS statements but potentially compatible with other banks.

## Requirements

- Python 3.7 or 3.8

# Installation

```
pip install ocbc-dbs-statement-parser
```

or if you're running it from source:

```
pip install -e .
```

# Usage

```
python -m ocbc-dbs-statement-parser <pdf_path> [--debug] [--verify] [--help]
```

Locally
```
python -m ocbc-dbs-statement-parser.cli <pdf_path> [--debug] [--verify][--help]
```

## Features

- Extracts transactions from bank account and credit card statements
- Supports various date formats
- Verifies transaction totals
- Debug mode for detailed output

## Development

### Setup

1. Clone the repository
2. Create a virtual environment: `python -m venv venv`
3. Activate the virtual environment:
   - Windows: `venv\Scripts\activate`
   - macOS/Linux: `source venv/bin/activate`
4. Install dependencies: `pip install -r requirements.txt`

### Testing

To run tests using pytest, execute the following command:

```
pytest tests/test_main.py
```

### Push releases

```
bumpversion patch|minor|major
git push && git push --tags
```

## Dependencies

The main dependencies for this project are:

- camelot-py==0.11.0
- pandas==2.0.3
- pycountry==24.6.1
- pypdf==4.3.1

For a complete list of dependencies, please refer to the `requirements.txt` file.

## License

This project is licensed under the MIT License.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.