semvec/pypi-packages huggingface dataset:
oneocr 1.0.11
Snipping Tool OCR for Windows
Requires Python: >=3

Originally from: https://b1tg.github.io/post/win11-oneocr/ and https://github.com/Cecilia-pj/win11_oneocr_py. Webserver code from https://github.com/GitHub30/winocr .
Basic library which returns a dict with the text, text angle, lines, and words in each line (with text, bounding boxes and confidence values for each word) using the Snipping Tool OCR on Windows. It also includes a small web server to serve OCR requests, as inspired by WinOCR.

To use you need to place 3 files from recent Windows 11 versions of Snipping Tool. The easiest way to get them is through https://store.rg-adguard.net, insert "https://apps.microsoft.com/detail/9mz95kl8mr0l" in the search box and download the most recent "Microsoft.ScreenSketch" "msixbundle" file. Then rename it to .zip and extract it. Extract the "SnippingToolApp" "msix" file for your architecture (x64 or ARM64) again after also renaming it to .zip, and the files should be in the "SnippingTool" folder.

- oneocr.dll
- oneocr.onemodel
- onnxruntime.dll

These files should be placed in the C:/Users/your_user_folder/.config/oneocr folder.

Usage is similar to WinOCR:

```py
from PIL import Image
import oneocr

img = Image.open('test.jpg')
model = oneocr.OcrEngine()
model.recognize_pil(img)['text']
```

```py
import requests

bytes = open('test.jpg', 'rb').read()
requests.post('http://localhost:8001/', bytes).json()['text']
```

```py
import cv2
import oneocr

img = cv2.imread('test.jpg')
model = oneocr.OcrEngine()
model.recognize_cv2(img)['text']
```

To run the server:
```
pip install oneocr[api]
oneocr_serve
```

The returned dict looks like this:
```py
{'text': '(Press CTRL+C to quit)', 'text_angle': 0.06437717378139496, 'lines': [{'text': '(Press CTRL+C to quit)', 'bounding_rect': {'x1': 13.0, 'y1': 38.0, 'x2': 458.0, 'y2': 38.0, 'x3': 458.0, 'y3': 77.0, 'x4': 13.0, 'y4': 76.0}, 'words': [{'text': '(Press', 'bounding_rect': {'x1': 14.353108406066895, 'y1': 39.69878387451172, 'x2': 140.3456573486328, 'y2': 41.31085205078125, 'x3': 139.93304443359375, 'y3': 73.41635131835938, 'x4': 13.778392791748047, 'y4': 74.0859375}, 'confidence': 0.9870722889900208}, {'text': 'CTRL+C', 'bounding_rect': {'x1': 155.53341674804688, 'y1': 41.37630844116211, 'x2': 273.66094970703125, 'y2': 41.40755081176758, 'x3': 273.42254638671875, 'y3': 74.35794830322266, 'x4': 155.1415557861328, 'y4': 73.46490478515625}, 'confidence': 0.9822005033493042}, {'text': 'to', 'bounding_rect': {'x1': 298.973388671875, 'y1': 41.21086502075195, 'x2': 334.41058349609375, 'y2': 40.91863250732422, 'x3': 334.25103759765625, 'y3': 75.33767700195312, 'x4': 298.7672424316406, 'y4': 74.74362182617188}, 'confidence': 0.9981738328933716}, {'text': 'quit)', 'bounding_rect': {'x1': 357.4715881347656, 'y1': 40.60407257080078, 'x2': 459.0, 'y2': 38.89320755004883, 'x3': 459.0, 'y3': 78.0, 'x4': 357.3414306640625, 'y4': 75.82363891601562}, 'confidence': 0.9932758808135986}]}]}
```
pydartdiags 0.6.5
Observation Sequence Diagnostics for DART
Requires Python: >=3.8

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![codecov](https://codecov.io/gh/NCAR/pyDARTdiags/graph/badge.svg?token=VK55SQZSVD)](https://codecov.io/gh/NCAR/pyDARTdiags)
[![PyPI version](https://badge.fury.io/py/pydartdiags.svg)](https://pypi.org/project/pydartdiags/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

# pyDARTdiags

pyDARTdiags is a Python library for observation space diagnostics for the Data Assimilation Research Testbed ([DART](https://github.com/NCAR/DART)).

pyDARTdiags is under initial development, so please use caution.
The MATLAB [observation space diagnostics](https://docs.dart.ucar.edu/en/latest/guide/matlab-observation-space.html) are available through [DART](https://github.com/NCAR/DART).


pyDARTdiags can be installed through pip: https://pypi.org/project/pydartdiags/  
Documentation : https://ncar.github.io/pyDARTdiags/

## Contributing
Contributions are welcome! If you have a feature request, bug report, or a suggestion, please open an issue on our GitHub repository.
Please read our [Contributors Guide](https://github.com/NCAR/pyDARTdiags/blob/main/CONTRIBUTING.md) if you would like to contribute to
pyDARTdiags.

## License

pyDARTdiags is released under the Apache License 2.0. For more details, see the LICENSE file in the root directory of this source tree or visit [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
cumulus-library-loinc 1.0.0
A LOINC ontology study for the Cumulus project
Requires Python: >=3.11
Keywords: FHIR, SQL, Health Informatics

# Cumulus Library LOINC

An installation of the LOINC® ontology. Part of the 
[SMART on FHIR Cumulus Project](https://smarthealthit.org/cumulus)

For more information,
[browse the documentation](https://docs.smarthealthit.org/cumulus/library).

## Usage

You can install this module by running `pip install cumulus-library-loinc`.

This will add a `loinc` target to `cumulus-library`. 

The contents of this dataset are described at the
[LOINC website](https://loinc.org/).
You will need to register an account on their website to use this data. When you build
this study, you'll need to provide your user and password as custom options. Your build
command should look like this:

```bash
cumulus-library build -t loinc --loinc_user your_username --loinc_password your_password [any other cli agurments]
```

You can, if you prefer, create environment variables to hold this data. We'll check for the
prescence of `LOINC_USER` and `LOINC_PASSWORD` if the CLI arguments are not provided.

Note: This study is explicitly namespaced in its own schema, `loinc`. Make sure your
database is not using this schema for another use. Do not create tables inside this
schema by another means.

## Tables

We are currently inserting a subset of Loinc tables, focused on Cumulus use cases:

- The LOINC core table, and its associated mapping table for older versions
- The group tables (see the [groups page](https://loinc.org/groups/) for usage caveats)
- The consumer names of medications
- The document ontology
- The lab order value set

## Licensing details

This material contains content from LOINC (http://loinc.org). LOINC is copyright © Regenstrief
Institute, Inc. and the Logical Observation Identifiers Names and Codes (LOINC) Committee and 
is available at no cost under the license at http://loinc.org/license. LOINC® is a registered 
United States trademark of Regenstrief Institute, Inc.

Where the product or service is distributed with a printed license, this notice must appear in
the printed license. Where the product or service is distributed on a fixed storage medium, a
text file containing this notice also must be stored on the storage medium in a file called 
"LOINC_short_license.txt." Where the product or service is distributed via the Internet, this
notice must be accessible on the same Internet page from which the product is available for
download. Where the product or service is provided as an online resource (e.g., to be accessed
programmatically through an application programming interface (API) or through a user interface),
this notice must be available in the license or terms of use.
pytest-celery-utils 0.1.2
Pytest plugin for inspecting Celery task queues in Redis during tests
Requires Python: >=3.11
Keywords: pytest, celery, testing, redis

# Inspect Celery Queues with Pytest

I love Celery for background tasks, but testing them can be a headache. Usually, you have to run a worker or mock everything out. But sometimes you just want to know: "Did my task actually get queued in Redis?" and "Is the payload correct?"

That's why I put together `pytest-celery-utils`. It's a simple plugin that lets you peek directly into your Redis-backed Celery queues during your tests. No workers required—just pure inspection.

## Installation

Grab it with `uv`:

```bash
uv add --dev pytest-celery-utils
```

## Usage

Once installed, you get a `celery_utils` fixture. It's automatically available, so you can just drop it into your tests.

Here's how I use it to verify tasks are queuing up correctly:

```python
def test_task_queued(celery_utils):
    # Fire off a task
    my_task.delay(arg1, arg2)

    # Get all queued tasks
    tasks = celery_utils.get_all_queued_tasks()
    assert len(tasks) > 0

    # Get tasks of specific type
    my_tasks = celery_utils.jobs_of_type("myapp.tasks.my_task")
    assert len(my_tasks) == 1
```

You'll need a `celery_app` fixture configured in your `conftest.py` so the plugin knows where to look:

```python
import pytest
from celery import Celery

@pytest.fixture
def celery_app():
    # Make sure to point to your Redis instance
    return Celery("myapp", broker="redis://localhost:6379/0")
```

## Features

*   **Direct Redis Inspection:** Look at what's actually in your queue without needing a running worker.
*   **Task Counting:** Easily assert that `n` jobs of a specific type are queued.
*   **Job Filtering:** Grab all jobs or filter them by task name (string or callable).
*   **Queue Support:** Inspects all queues defined in your Celery app.
*   **Nested Data Access:** Includes a handy `dig` utility for traversing those deeply nested Celery message dicts.

## Limitations

Just a heads up: this is strictly for **Redis** brokers. If you're using RabbitMQ or SQS, this won't work for you. It's also designed for testing, so don't expect it to be blazing fast for production monitoring.

# [MIT License](LICENSE.md)