semvec/pypi-packages huggingface dataset:
airthings-ble 1.2.0
Manage Airthings BLE devices
Requires Python: >=3.11

# airthings-ble

Library to control Airthings devices through BLE, primarily meant to be used in
the [Home Assistant integration](https://www.home-assistant.io/integrations/airthings_ble/).

## Supported devices

This library supports the following Airthings devices:

- [Corentium Home 2](https://www.airthings.com/products/corentium-home-2)
- [Wave Enhance](https://www.airthings.com/wave-enhance)
- Wave Gen 1
- [Wave Mini](https://www.airthings.com/wave-mini)
- [Wave Plus](https://www.airthings.com/wave-plus)
- [Wave Radon](https://www.airthings.com/wave-radon)

## Unsupported devices
Although some other devices have BLE capabilities, they use BLE only for onboarding and configuration. It is **not** possible to fetch sensor data using this library from, for example:

-	Hub
-	[Renew](https://www.airthings.com/renew)
-	[View Plus](https://www.airthings.com/view-plus)
-	View Pollution
-	[View Radon](https://www.airthings.com/view-radon)

## Getting Started

Prerequisites:

- [Python](https://www.python.org/downloads/) with version 3.12 that is required by Home Assistant ([docs](https://developers.home-assistant.io/docs/development_environment?_highlight=python&_highlight=versi#manual-environment) or [reference](https://github.com/home-assistant/architecture/blob/master/adr/0002-minimum-supported-python-version.md))
- [Poetry](https://python-poetry.org/docs/#installation)

Install dependencies:

```bash
poetry install
```

Run tests:

```bash
poetry run pytest
```

See [this wiki page](https://github.com/Airthings/airthings-ble/wiki/Testing-with-Home-Assistant) for more details
on how to test the library with HA.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
hed-tensor 1.0.1
Holistic Edge Detection (HED) model for TensorFlow/Keras with bundled pretrained weights
Requires Python: >=3.7

# HED-Tensor: Holistic Edge Detection

A TensorFlow/Keras implementation of **Holistically-Nested Edge Detection (HED)** with **pretrained weights included**. Use it as easily as VGG16 or ResNet!

## 🚀 Quick Start

### Installation

```bash
pip install hed-tensor
```

### Usage (3 lines!)

```python
from hed_tensor import HED, detect_edges

model = HED()  # Weights automatically load!
edges = detect_edges('your_image.jpg', model=model)
```

That's it! No need to download weights separately. 🎉

## 📦 Features

✅ **Pretrained weights included** - No extra downloads needed  
✅ **Simple API** - Just like using VGG16 or ResNet  
✅ **Multiple input formats** - Works with file paths, PIL Images, or NumPy arrays  
✅ **Batch processing** - Process multiple images efficiently  
✅ **TensorFlow 2.x** - Modern and fast  

## 🎯 Examples

### Basic Usage

```python
from hed_tensor import HED, detect_edges
from PIL import Image

# Load model (weights auto-load)
model = HED()

# Detect edges
edges = detect_edges('image.jpg', model=model)

# Save result
Image.fromarray(edges).save('edges.png')
```

### Using NumPy arrays

```python
import numpy as np
from hed_tensor import HED, detect_edges

model = HED()
image_array = np.array(Image.open('image.jpg'))
edges = detect_edges(image_array, model=model)
```

### Batch Processing

```python
from hed_tensor import batch_detect_edges, HED

model = HED()
image_paths = ['img1.jpg', 'img2.jpg', 'img3.jpg']

edge_maps = batch_detect_edges(
    image_paths, 
    model=model, 
    output_dir='output_edges'
)
```

### Load Custom Weights

```python
# Use your own trained weights
model = HED(weights='path/to/your/checkpoint.h5')

# Or skip loading weights
model = HED(weights=None)
```

## 📋 Requirements

- Python >= 3.7
- TensorFlow >= 2.4.0
- NumPy >= 1.19.0
- Pillow >= 8.0.0

## 🎓 Citation

If you use this package in your research, please cite the original HED paper:

```bibtex
@inproceedings{xie2015holistically,
  title={Holistically-nested edge detection},
  author={Xie, Saining and Tu, Zhuowen},
  booktitle={Proceedings of the IEEE International Conference on Computer Vision},
  pages={1395--1403},
  year={2015}
}
```

## 📄 License

MIT License

## 👨‍💻 Author

**Mohammad Saad Nathani**  
📧 saadnathani2005@gmail.com

## 🤝 Contributing

Contributions are welcome!

---

**Made with ❤️ for the Computer Vision community**
ecco-access 0.3.1
Access utilities for ECCO state estimate output hosted on PO.DAAC and in the AWS cloud
Requires Python: >=3.11
Keywords: ecco, climate, mitgcm, estimate, circulation, climate

## Description

`ecco_access` is a Python package with utilities for accessing output from the Estimating the Circulation and Climate of the Ocean (ECCO) state estimate. These tools enable the user to query and download ECCO output to their local machine, or directly access the ECCO output when working in the AWS Cloud.

Currently access to ECCO version 4, releases 4 and 5 are supported. Additional versions will be made available as they are released through the Physical Oceanography Distributed Active Archive Center (PO.DAAC), or made available on the ECCO S3 bucket in the AWS Cloud (s3://ecco-model-granules).

There is some overlap in functionality with the [earthaccess](https://earthaccess.readthedocs.io/en/stable/) Python package for accessing NASA Earth science data, and datasets on PO.DAAC/NASA Earthdata can be accessed with both packages. However, `ecco_access` has some ECCO-specific features that enable:

- querying of the variables in ECCO datasets
- spatial subsetting of ECCO output in the 13-tile Lat-Lon-Cap (LLC) native grid
- access on the AWS Cloud to ECCO release(s) not yet available through NASA Earthdata

## Documentation

Documentation on how to use `ecco_access`, including installation/setup requirements and instructions, can be found on ReadtheDocs: https://ecco-access.readthedocs.io

## Support

If you have questions or notice a bug, please reach out to andrewdelman@ucla.edu.

## Contributors

If you have Python code that would be helpful for accessing ECCO data or adding new features, we'd love to include your contributions! Feel free to [create a fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo) of this repository and after including your changes, submit a pull request to the `main` branch of the original repository. Or contact andrewdelman@ucla.edu to discuss.
chancy 0.25.1
A simple and flexible job queue for Python
Requires Python: >=3.11

# Chancy

![Chancy Logo](misc/logo_small.png)

Chancy is a distributed task queue and scheduler for Python built on top of
Postgres.

![MIT License](https://img.shields.io/github/license/tktech/chancy)
![Codecov](https://img.shields.io/codecov/c/github/TkTech/chancy)
![PyPI Version](https://img.shields.io/pypi/v/chancy)
![Python Version](https://img.shields.io/pypi/pyversions/chancy)
![OS Platforms](https://img.shields.io/badge/OS-Linux%20|%20macOS%20|%20Windows-blue)
![PostgreSQL Versions](https://img.shields.io/badge/PostgreSQL-%2014%20|%2015%20|%2016%20|%2017%20|%2018-blue)

## Key Features

- **Robust Jobs** - support for priorities, retries, timeouts, scheduling,
  global rate limits, memory limits, global uniqueness, error
  capture, cancellation, and more
- **Minimal dependencies** - Core functionality requires only psycopg3 - which
  can be installed side-by-side with psycopg2.
- **Minimal infrastructure** - No need to run a separate service like
  RabbitMQ or redis. Every feature is built on top of Postgres. No need
  for separate monitoring services like Flower or schedulers like Celery
  Beat - everything is built-in to the worker.
- **Plugins** - Several plugins including a dashboard, workflows, cron jobs,
  and more.
- **Flexible** - A single worker can handle many queues and mix threads,
  processes, sub-interpreters, and asyncio jobs, allowing powerful workflows
  that use the optimal concurrency model for each job. Queues can be created,
  deleted, modified, and paused at runtime.
- **async-first** - Internals designed from the ground up to be async-first,
  but has minimal sync APIs for easy integration with existing non-async
  codebases.
- **Transactional enqueueing** - Atomically enqueue jobs and the data they
  depend on in a single transaction.
- **Performant** - Used in production environments to process millions of
  jobs per day.
- **Portable** - Supports Linux, OS X, and Windows.
- **100% open & free** - no enterprise tiers or paid features.

## Documentation

Check out the getting-started guide and the API documentation at
https://tkte.ch/chancy/.

## Screenshots

Chancy comes with an optional dashboard that provides a basic
look into the status of your queues:

![Workflows](misc/ux_workflow.png)
![Queue Details](misc/ux_queue.png)
![Jobs](misc/ux_jobs.png)
![Job](misc/ux_job_failed.png)
malac-transformer-fhir 1.1.2
MaLaC FHIR Transformers
Requires Python: >=3.10

# MaLaC FHIR Transformer

MaLaC-HD (MApping LAnguage Compiler for Health Data) is a tool that you can use to convert mappings between different health data formats to executable code. It can also be used as a library to dynamically execute mappings.

This is the FHIR transformer package that contains official transformations, mainly between different FHIR releases. You can use it independently from the `malac-hd` package to perform these transformations.

[TOC]

## Contributing and Support

Please read [CONTRIBUTING.md](CONTRIBUTING.md) for contributing to cdeHealth projects which are hosted in the [cdeHealth group](https://gitlab.com/cdehealth) on GitLab.com.
Please read [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) to make participation in our community a harassment free experience for everyone.

## License
TODO