semvec/pypi-packages huggingface dataset:
oneargopy 0.1.7
An alpha version of oneargopy.
Requires Python: >=3.10

# OneArgoPy
A Python library for accessing and visualizing Argo data.

The recommended installation is via pip (pip install oneargopy).

The included Jupyter notebook (oneargopy_demo.ipynb) demonstrates the basic usage of this library.

Python >= 3.10 is required for this library.

## Authors

* Savannah Stephenson (sstephenson2@islander.tamucc.edu)
* Hartmut Frenzel (hfrenzel@uw.edu)
moana-astro 0.3.0
MOAna: Microlensing Observations ANAlysis tools
Requires Python: >=3.10

MOAna
=====

.. image:: https://img.shields.io/badge/GitHub-clementranc%2Fmoana-blue
   :target: https://github.com/clementranc/moana
.. image:: https://img.shields.io/github/license/clementranc/moana?color=blue
   :target: https://github.com/clementranc/moana/blob/master/LICENSE
   :alt: GitHub License
.. image:: https://readthedocs.org/projects/ulat/badge/?version=latest
   :target: https://ulat.readthedocs.io/en/latest/?badge=latest
   :alt: Documentation Status
.. image:: https://zenodo.org/badge/240124626.svg
   :target: https://zenodo.org/badge/latestdoi/240124626

MOANA (or MOAna) stands for Microlensing Observations ANAlysis tools. This package replaces uLAT (Micro-Lensing Analysis Tools) that has been renamed on October 2020. This python package is a work in progress, not yet designed for general use. A temporary documentation is available at https://ulat.readthedocs.io/.

If you use this code, please add a reference to:

.. code-block:: tex

   @software{moana,
     author       = {Clément Ranc},
     title        = {Microlensing Observations ANAlysis tools},
     month        = nov,
     year         = 2020,
     publisher    = {Zenodo},
     version      = {v0.1},
     doi          = {10.5281/zenodo.4257009},
     url          = {https://doi.org/10.5281/zenodo.4257009}
   }
aces-high-core-py 0.1.1
Base library for card game logic
Requires Python: >=3.10



# Aces High: Core Python Library

A Python library for modeling playing cards, decks, and core logic for traditional card games. Built with clean, testable design principles and designed to serve as the foundation for more complex gameplay logic.

> 🧠 Built to teach — this library powers the examples in the companion eBook:  
> [**Building Systems Like a Senior Engineer**](https://github.com/asmitty92/aces-high-ebook)

---

## Features

- 🎴 Card and Deck modeling using Pythonic, enum-safe data structures
- 🔁 Standard shuffling, dealing, and deck state management
- 🧪 Fully tested with `pytest`, using a test-first design process
- 🧹 Enforced code quality via `black` and `ruff`
- 📦 Easy-to-install package, published to [PyPI](https://pypi.org/project/aces-high-core/)

---

## Installation

```bash
pip install aces-high-core-py
```

---

## Usage

```python
from aces_high import StandardDeck

deck = StandardDeck()
deck.shuffle()

hand = deck.deal(5)
for card in hand:
    print(card)
```

---

## Development

Clone the repo and install dependencies with [uv](https://github.com/astral-sh/uv):

```bash
uv venv
source .venv/bin/activate
uv pip install -r requirements.txt
```

Run tests:

```bash
pytest
```

Format and lint:

```bash
black src/ tests/
ruff check src/ tests/
```

---

## Publishing

We use `uv publish` and `workflow_dispatch` in GitHub Actions for controlled PyPI deploys. See the `Publish to PyPI` workflow for more.

---

## License

MIT License © Aaron Smith

---

## See Also

📘 [**Aces High eBook**](https://github.com/asmitty92/aces-high-ebook) — Learn how this library was designed and built from scratch, with a focus on practical system design and senior engineering practices.
zarrdataset 0.2.2
Zarr-based dataset for PyTorch training pipelines. Written and maintained by the Research IT team at The Jackson Laboratory.
Requires Python: >=3.9

# ZarrDataset
A class for handling large-volume datasets stored in OME-NGFF Zarr format.
This can be used primarly with PyTorch's DataLoader in machine learning training workflows.

## Usage
```
import zarrdataset as zds

# Open a set of Zarr files stored locally or in a S3 bucket. Must specify the
# group/component were the arrays are stored within the zarr file, and the 
# order of the axes of the dataset.
my_dataset = zds.ZarrDataset(
  dict(
    modality="images",
    filenames=["https://uk1s3.embassy.ebi.ac.uk/idr/zarr/v0.1/9836839.zarr"],
    source_axes="TCZYX",
    data_group="0"
  ),
)
```

## Integration
The **ZarrDataset** class is derived from PyTorch's _IterableDataset_ class, and can be used with a _DataLoader_ object to generate batches of inputs for machine learning training workflows.

```
from torch.utils.data import DataLoader
import zarrdataset as zds

my_dataset = zds.ZarrDataset(...)

# Generate batches of 16 images, uisng four threads.
# Pass the worker initialization function from zarrdataset to the DataLoader
my_dataloader = DataLoader(my_dataset,
                           batch_size=16,
                           num_workers=4,
                           worker_init_fn=zds.zarrdataset_worker_init_fn)

for x, t in my_dataloader:
    # The training loop
    ...
    output = model(x)
    loss = criterion(output, t)
    ...
```
### Multithread data loading
Use of multiple workers through multithread requires the use of the **zarrdataset_worker_init_fn** function provided in this package.
This allows to load only a fraction of the dataset on each worker instead of the full dataset.

### Patch sampling
**ZarrDataset** retrieve the whole array contained in *data_group* by default.
To retrieve patches from that array instead, use any of the two samplers provided within this package, or implement a custom one derived from the **PatchSampler** class.

The two existing samplers are **PatchSampler** and **BlueNoisePatchSampler**.
**PatchSampler** retrieves patches from an evenly distributed grid of non-overlapping squared patches of side *patch_size*.
**BlueNoisePatchSampler** retrieves patches of side *patch_size* from random locations following [blue-noise sampling](https://blog.demofox.org/2017/10/20/generating-blue-noise-sample-points-with-mitchells-best-candidate-algorithm/).
The patch sampler can be integated into a **ZarrDataset** object as follows.
```
import zarrdataset as zds

# Retrieve patches of size patch_size in an evenly spaced grid from the image.
my_patch_sampler = zds.PatchSampler(patch_size)

my_dataset = zds.ZarrDataset(...,
                             patch_sampler=my_patch_sampler)
```

Examples of integration of the **ZarrDataset** class with the PyTorch's **DataLoader** can be found in the [documentation](https://thejacksonlaboratory.github.io/zarrdataset/index.html).

## Installation
This package can be installed from PyPI with the following command
```
pip install zarrdataset
```
solana-trade 1.0.0
This Python library provides utilities to fetch token prices from decentralized exchanges (DEXs) across Ethereum and Solana networks. It uses Web3.py for Ethereum and the Solders library for Solana, along with other utilities to interact with DEXs like Uniswap, Sushiswap, Pancakeswap (Ethereum), and Serum (Solana).
Requires Python: >=3.9

# DEX Price Fetching Library for Ethereum and Solana

This Python library provides utilities to fetch token prices from decentralized exchanges (DEXs) across Ethereum and Solana networks. It uses Web3.py for Ethereum and the Solders library for Solana, along with other utilities to interact with DEXs like Uniswap, Sushiswap, Pancakeswap (Ethereum), and Serum (Solana).

## Features

- **Ethereum (Uniswap, Sushiswap, Pancakeswap)**: 
  - Fetch prices of tokens.
  - Get pair address and reserves for token pairs.
  - Retrieve token symbol, total supply, and decimals.
  - Get the current block number and gas price.
  
- **Solana (Serum)**:
  - Fetch prices from Serum DEX on Solana.
  - Get the token balance of any Solana address.
  - Retrieve Solana transaction fees and account balances.

- **Utilities**:
  - Fetch the total supply of ERC-20 tokens.
  - Retrieve Solana transaction statuses.
  - Convert Base58 addresses to Solana public keys.

## Requirements

- Python 3.x
- Install required libraries via `pip`: