semvec/pypi-packages huggingface dataset:
eckitlib 1.32.4.11
"eckitlib"

eckit
=====

[![Latest Tag](https://img.shields.io/github/v/tag/ecmwf/eckit?label=latest&style=flat-square&logo=github)](https://github.com/ecmwf/eckit/tags)
[![CI](https://img.shields.io/github/actions/workflow/status/ecmwf/eckit/ci.yml?branch=master&label=ci%20(master)&style=flat-square&logo=github)](https://github.com/ecmwf/eckit/actions/workflows/ci.yml)
[![CI](https://img.shields.io/github/actions/workflow/status/ecmwf/eckit/ci.yml?branch=develop&label=ci%20(develop)&style=flat-square&logo=github)](https://github.com/ecmwf/eckit/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/ecmwf/eckit/branch/develop/graph/badge.svg)](https://codecov.io/gh/ecmwf/eckit)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ecmwf/eckit/blob/develop/LICENSE)

Project home: https://software.ecmwf.int/wiki/display/ECKIT


ecKit is a cross-platform C++ toolkit that supports development of tools and
applications at ECMWF. It is based on code developed over the last 20 years
within the MARS software and was re-factored out to be reused by other
applications. It provides a an abstraction layer on top of the operating
system, so it is easier to port code to new architectures. It is developed
taking into account the robustness requirements of running production systems
at ECMWF. The main focus is UNIX/POSIX systems, and it has been thoroughly
tested on AIX, Linux and Mac OSX. Historically, the code base pre-dates and in
some way can be seen as a leaner substitute for some 'Boost' libraries.

It features facilities to easily handle, in a cross-platform way:
* multi-threading
* json and yaml parsing
* object serialization and persistence
* object serialization supporting compression, to and from file and network
* configuration of user options and resources
* file-system abstraction
* regular expressions
* socket networking
* http protocol
* type-to-type conversions
* asynchronous IO
* asynchronous processing
* exception handling and stack dumping
* MPI object-oriented wrapper
* linear algebra abstraction with multiple backends (BLAS, MKL, Armadillo, Eigen3)
* advanced container classes
* space partition trees
* file-mapped arrays


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

Tested compilers include:

- GCC 4.9.1, 5.3.0, 6.3.0, 7.2.0
- Intel 15.0.2, 16.0.3, 17, 18
- CCE 8.4.5, 8.5.8, 8.6.2
- Apple LLVM 9.1.0 (clang-902.0.39.1)

Required dependencies:

- CMake --- For use and installation see http://www.cmake.org/
- ecbuild --- ECMWF library of CMake macros
- Perl5 --- For some code generation


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

Eckit employs an out-of-source build/install based on CMake.

Make sure ecbuild is installed and the ecbuild executable script is found ( `which ecbuild` ).

Now proceed with installation as follows:

```bash
# Environment --- Edit as needed
srcdir=$(pwd)
builddir=build
installdir=$HOME/.local

# 1. Create the build directory:
mkdir $builddir
cd $builddir

# 2. Run CMake
ecbuild --prefix=$installdir -- $srcdir

# 3. Compile / Install
make -j10
make install

# 4. Check installation
$installdir/bin/eckit-version
```
Refined-Augment 0.1.0
This package allows you to detect faces in real-time using a webcam and overlay an AR object above the detected face.
Requires Python: >=3.7

# AR Face Overlay Package

This package allows you to detect faces in real-time using a webcam and overlay an image (sticker) above the detected face. It includes built-in system checks to ensure your hardware can run the processing smoothly.

Prerequisites:
The package requires Python 3.7 or higher and the following libraries:
- opencv-python
- numpy
- psutil

they will be Installed automatically using pip:
```bash
pip install opencv-python numpy psutil
```
## Usage:

You can start the application by importing the package in your main script (test.py for example).
```bash
import AI_augment as ar

# Run with your custom image
ar.start(image_path='AR_photo.png')
```
## How It Works :

- System Check: The program verifies if you have at least 2GB of RAM and 2 CPU cores to prevent lag.

- Resource Management: It automatically searches for the haarcascade_frontalface_default.xml file. If the file is not found locally or in the OpenCV system folder, it downloads it from the official repository.

- Perspective Warping: The program uses a homography matrix to scale and position the overlay image so it follows the movement of the face.

## File Descriptions :

Diagnostics.py: Contains functions to check RAM, CPU, and camera availability. It also handles the path resolution for the Haar Cascade XML file.

Engine.py: Contains the main loop that processes video frames, detects faces, and applies the image overlay logic.

init.py: Acts as the package interface, coordinating the diagnostics and the engine.

## Controls :
'q': Press the 'q' key on your keyboard to stop the video feed and close the application.

Troubleshooting
Image Load Error: Ensure the image path provided in ar.start() is correct relative to where you are running the script.

Camera Error: If the camera access fails, check if another application is using the webcam.

Persistence Error: This occurs if the XML file is corrupted or missing. The program will attempt to re-download it if you delete the existing XML file in the directory.
langgraph-checkpoint-conformance 0.0.1
Conformance test suite for LangGraph checkpointer implementations.
Requires Python: >=3.10

# langgraph-checkpoint-conformance

Conformance test suite for [LangGraph](https://github.com/langchain-ai/langgraph) checkpointer implementations.

Validates that a `BaseCheckpointSaver` subclass correctly implements the checkpoint storage contract — blob round-trips, metadata preservation, namespace isolation, incremental channel updates, and more.

## Installation

```bash
pip install langgraph-checkpoint-conformance
```

## Quick start

Register your checkpointer with `@checkpointer_test` and run `validate()`:

```python
import asyncio
from langgraph.checkpoint.conformance import checkpointer_test, validate

@checkpointer_test(name="MyCheckpointer")
async def my_checkpointer():
    saver = MyCheckpointer(...)
    yield saver
    # cleanup runs after yield

async def main():
    report = await validate(my_checkpointer)
    report.print_report()
    assert report.passed_all_base()

asyncio.run(main())
```

Or in a pytest test:

```python
import pytest
from langgraph.checkpoint.conformance import checkpointer_test, validate

@checkpointer_test(name="MyCheckpointer")
async def my_checkpointer():
    yield MyCheckpointer(...)

@pytest.mark.asyncio
async def test_conformance():
    report = await validate(my_checkpointer)
    report.print_report()
    assert report.passed_all_base()
```

## Capabilities

The suite tests **base** capabilities (required) and **extended** capabilities (optional, auto-detected):

| Capability | Required | Method |
|---|---|---|
| `put` | yes | `aput` |
| `put_writes` | yes | `aput_writes` |
| `get_tuple` | yes | `aget_tuple` |
| `list` | yes | `alist` |
| `delete_thread` | yes | `adelete_thread` |
| `delete_for_runs` | no | `adelete_for_runs` |
| `copy_thread` | no | `acopy_thread` |
| `prune` | no | `aprune` |

Extended capabilities are detected by checking whether the method is overridden from `BaseCheckpointSaver`. If not overridden, those tests are skipped.

## Options

### Progress output

```python
from langgraph.checkpoint.conformance.report import ProgressCallbacks

# Dot-style progress (. per pass, F per fail)
report = await validate(my_checkpointer, progress=ProgressCallbacks.default())

# Verbose (per-test names + stacktraces on failure)
report = await validate(my_checkpointer, progress=ProgressCallbacks.verbose())
```

### Skip capabilities

```python
@checkpointer_test(name="MyCheckpointer", skip_capabilities={"prune"})
async def my_checkpointer():
    yield MyCheckpointer(...)
```

### Run specific capabilities

```python
report = await validate(my_checkpointer, capabilities={"put", "list"})
```

### Lifespan (one-time setup/teardown)

For expensive setup like database creation:

```python
async def db_lifespan():
    await create_database()
    yield
    await drop_database()

@checkpointer_test(name="PostgresSaver", lifespan=db_lifespan)
async def pg_checkpointer():
    async with PostgresSaver.from_conn_string(CONN_STRING) as saver:
        yield saver
```
t3api-utils 1.4.0
Utility functions and helpers for the T3 API ecosystem
Requires Python: >=3.12
Keywords: t3, metrc, utils, helpers, track and trace

# t3api-python-utils

Utility functions and helpers for the T3 API ecosystem.

This library is designed to support development of tools and clients that integrate with the Track & Trace Tools (T3) platform and Metrc data. It includes shared logic, validation helpers, transformation utilities, and other reusable Python components.

---

## 🚀 Getting Started

### 1. Clone the repo

```bash
git clone https://github.com/classvsoftware/t3api-python-utils.git
cd t3api-python-utils
````

### 2. Create virtual environment with `uv`

```bash
uv venv
source .venv/bin/activate
```

### 3. Install the package (editable mode)

```bash
uv pip install -e .
```

---

## 🧪 Running Tests

```bash
pytest
```

Add test modules under the `tests/` directory.

---

## 🛠️ Development Tips

* All core source files live in the `t3api_python_utils/` directory.
* Add type annotations and follow [PEP 8](https://peps.python.org/pep-0008/) and [mypy strict rules](https://mypy.readthedocs.io/en/stable/config_file.html).

---

## 📦 Building the Package

Make sure your virtualenv is activated:

```bash
uv pip install build
python -m build
```

This generates `.tar.gz` and `.whl` files inside the `dist/` folder.

---

## 🚀 Publishing to PyPI

### 1. Install Twine

```bash
uv pip install twine
```

### 2. Upload to TestPyPI (recommended for first-time testing)

```bash
twine upload --repository testpypi dist/*
```

Test it via:

```bash
uv pip install --index-url https://test.pypi.org/simple/ t3api-python-utils
```

### 3. Upload to PyPI (when ready)

```bash
twine upload dist/*
```

You’ll need a valid `.pypirc` file or Twine will prompt for your PyPI credentials.

---

## 📎 License

Licensed under the GNU General Public License v3.0.

---

## 🔗 Links

* [Documentation](https://classvsoftware.github.io/t3api-python-utils/)
* [T3 Website](https://trackandtrace.tools)
* [T3 API Docs](https://api.trackandtrace.tools/v2/docs)
* [GitHub Repo](https://github.com/classvsoftware/t3api-python-utils)

---
AIaugment 0.1.0
This package allows you to detect faces in real-time using a webcam and overlay an AR object above the detected face.
Requires Python: >=3.7

AR Face Overlay Package

This package allows you to detect faces in real-time using a webcam and overlay an image (sticker) above the detected face. It includes built-in system checks to ensure your hardware can run the processing smoothly.

Prerequisites:
The package requires Python 3.7 or higher and the following libraries:
- opencv-python
- numpy
- psutil

Install them using pip:
```bash
pip install opencv-python numpy psutil
```
the directory will look as following: