semvec/pypi-packages huggingface dataset:
arrayfile 0.0.1
Arrays backed by disk
Requires Python: >=3.10
Keywords: logging, terminal, scrollback, indexing

# arrayfile

A file-backed numeric array using struct.pack. Does not support inserts or
slicing.

Smaller than relying on numpy though.

## Installation

```bash
pip install arrayfile
```

## Usage

### Temporary Array

This creates an array in your temp dir:

```python
from arrayfile import Array

# Create a temporary array with float data
arr = Array('f')
arr.append(3.14)
arr.append(2.71)
arr.extend([1.41, 1.73])

print(f"Length: {len(arr)}")
print(f"Values: {[arr[i] for i in range(len(arr))]}")
arr.close()  # Clean up resources
```

### Persistent Array

You can use the same file, if you want to persist your data across sessions:

```python
from arrayfile import Array

# Create and populate an array file
arr = Array('i', 'numbers.array', 'w+b')
for i in range(1000):
    arr.append(i * 2)
arr.close()

# Reopen the same file later
arr = Array('i', 'numbers.array', 'r+b')
print(f"Array has {len(arr)} elements")
print(f"First element: {arr[0]}")
print(f"Last element: {arr[-1]}")

# Add more data
arr.append(2000)
arr.close()
```

## Context manager

It has a finalizer in case you forget to call `close()`, but if you like to keep
your code tidy, you can use a context manager, like so:

```python
from arrayfile import Array

# Using double precision floats with context manager
with Array('d', 'measurements.array', 'w+b') as arr:
    arr.extend([3.141592653589793, 2.718281828459045, 1.4142135623730951])

    print(f"Stored {len(arr)} precise measurements")
    for i, value in enumerate(arr):
        print(f"  {i}: {value:.15f}")
```
rencom-cli 1.0.3
Command-line interface for the Rencom Reviews API
Requires Python: >=3.8

# Rencom - Plug-and-Play E-commerce Reviews API

A modern, scalable API platform for collecting and displaying product reviews for any e-commerce store. No frontend, no platform lock-in—just robust, efficient APIs.

## 🚀 Features

- **API Token Authentication**: Secure, token-based access for all endpoints
- **Product Reviews**: Collect, store, and retrieve reviews for any product
- **Pagination & Performance**: Designed for scale (1k+ users, 15k+ reviews)
- **Supabase Backend**: Real-time, scalable PostgreSQL database
- **FastAPI**: High-performance Python backend
- **Docker-Ready**: Easy local development and deployment
- **CLI Onboarding**: Get started instantly with `rencom setup`

## 🛠️ Installation

### From PyPI (recommended for most users)
```bash
pip install rencom-cli
```

### From Source (for contributors/advanced users)
```bash
git clone <repository-url>
cd rencom
pip install .
```

## ⚡ Quick Start (API Users)

1. **Onboard Instantly**
   ```bash
   rencom setup
   ```
   - This will guide you through API onboarding and create your API token.

2. **Try the API**
   - Use your token to make requests:
   ```bash
   curl -X POST https://rencom-backend.fly.dev/api/v1/reviews \
     -H 'Authorization: Bearer <your-token>' \
     -H 'Content-Type: application/json' \
     -d '{"product_id": "prod-123", "user_id": "user-abc-123", "rating": 5, "comment": "Great!"}'
   ```
   - Or explore the full API in [Postman](https://documenter.getpostman.com/view/your-doc-id)

3. **Shell Completion (Optional)**
   - Enable tab completion for bash, zsh, fish, or PowerShell:
   ```bash
   rencom completion install bash --install
   # See COMPLETION.md for details
   ```

## 👩‍💻 Advanced: Local Development & Forking

If you want to run the API locally, contribute, or self-host:

1. **Fork and Setup Locally**
   ```bash
   rencom fork
   ```
   - This will walk you through forking, configuring, and running the codebase locally.

2. **Manual Setup (for reference)**
   - See the `fork` command or the `api/`, `config/`, and `services/` folders for advanced configuration.

## 📚 API Documentation
- See [PUBLIC_API_DOCS.md](PUBLIC_API_DOCS.md) for full endpoint details.
- Or use the CLI: `rencom help`

## 🤝 Contributing
- Use `rencom fork` to get started as a contributor.
- Standard PR workflow applies.

## 📄 License
MIT License

## 🆘 Support
- Create an issue in the GitHub repository
- Check the API documentation at `/docs`
chemicalmotifidentifier 0.0.10
Chemical Motif Identifier

# ChemicalMotifIdentifier
![PyPI Version](https://img.shields.io/pypi/v/chemicalmotifidentifier.svg) ![PyPI Downloads](https://static.pepy.tech/badge/chemicalmotifidentifier)

This repository contains the codes necessary to perform a chemical-motif characterization of short-range order, as described in our [Quantifying chemical short-range order in metallic alloys](https://www.pnas.org/doi/abs/10.1073/pnas.2322962121) paper and our [Chemical-motif characterization of short-range order using E(3)-equivariant graph neural networks](https://www.nature.com/articles/s41524-024-01393-5) paper. 

This framework allows for correlating any per-atom property to their local chemical motif. It also allows for the determination of predictive short-range chemical fluctuations length scale. It is based on E(3)-equivariant graph neural networks. Our framework has 100% accuracy in the identification of *any* motif that could ever be found in an fcc, bcc, or hcp solid solution with up to 5 chemical elements.  

![](assets/figure_2.png)

## Instalation 

```bash
# To install the latest PyPi release
pip install --upgrade chemicalmotifidentifier

# To install the latest git commit 
pip install --upgrade git+https://github.com/killiansheriff/ChemicalMotifIdentifier.git
```

You will also need to install ``torch``, ``torch_scatter`` and ``torch_geometric``.

## Example of usage

A jupyter notebook presenting a few test cases can be found in the [examples/](examples/) folder.

## References & Citing
If you use this repository in your work, please cite:

```
@article{sheriffquantifying2024,
	title = {Quantifying chemical short-range order in metallic alloys},
	doi = {10.1073/pnas.2322962121},
	journaltitle = {Proceedings of the National Academy of Sciences},
	author = {Sheriff, Killian and Cao, Yifan and Smidt, Tess and Freitas, Rodrigo},
	date = {2024-06-18},
}
```

and 

```
@article{sheriff2024chemicalmotif,
  title = {Chemical-motif characterization of short-range order with E(3)-equivariant graph neural networks},
  DOI = {10.1038/s41524-024-01393-5},
  journal = {npj Computational Materials},
  author = {Sheriff,  Killian and Cao,  Yifan and Freitas,  Rodrigo},
  year = {2024},
  month = sep,
}
```
first-level-fighter 0.1.0
DND 5E first-level character sheet generator
Requires Python: >=3.12

# first-level-fighter
A Dungeons &amp; Dragons 5th Edition character sheet generator for creating first-level character sheets as markdown documents.
List of names was created using [fantasynamegenerators.com](https://www.fantasynamegenerators.com/)

## Installation
If you have `uv` installed, you can install FLF by running
```
uv pip install first-level-fighter
```
Then, you can run the program by running
```
uv run flf
```

If you have `pipx` installed, you can install FLF by running
```
pipx install first-level-fighter
```
Then, you can run the program by running
```
flf
```

## Usage Notes
This tool was created as part of the [boot.dev](www.boot.dev/) curriculum as my first personal project.
There are undoubtedly more robust online tools for generating character sheets online, but this could still prove useful for any DM/GMs looking to *create simple sheets to help introduce brand-new players to the game*.
To ensure this project could be completed in a reasonable amount of time, a few things have been notably ommitted from FLF (AC, Spells, Feats, and statblocks for equipment).

Any omissions were made to ensure the project could be completed within 20-40 hours of time investment as per curriculum guidelines.
My suggestion? As a DM, you can use FLF to pre-generate sheets for players and fill-in/edit the output markdown files for your players to include more descriptive text and AC.
You can also introduce your players to online resources like [wikidot](https://dnd5e.wikidot.com/) and include links in the generated sheets for players to reference.

Consider using FLF in a one-shot to teach players the basics of DND with a more rules-loose approach!
(Does it *really* matter how much damage a firebolt does when you're just trying to get your players to think about roleplay and using all the tools in their kit?
Save that for a real campaign!
barnone 1.0.2
A lightweight, eye-friendly, and feature-rich terminal progress bar.
Requires Python: >=3.9

# BarNone

[![PyPI](https://img.shields.io/pypi/v/barnone?label=barnone)](https://pypi.org/project/barnone/)
![Python Versions](https://img.shields.io/badge/python-3.9+-blue?logo=python)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/barnone)](https://pypistats.org/packages/barnone)
[![GitHub issues](https://img.shields.io/github/issues/nickstuer/barnone.svg)](https://github.com/nickstuer/barnone/issues)

![Lines Of Code](https://tokei.rs/b1/github/nickstuer/barnone)
[![Codecov](https://img.shields.io/codecov/c/github/nickstuer/barnone)](https://app.codecov.io/gh/nickstuer/barnone)
[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/nickstuer/barnone/run_tests.yml)](https://github.com/nickstuer/barnone/actions/workflows/run_tests.yml)

[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
[![license](https://img.shields.io/github/license/nickstuer/barnone.svg)](LICENSE)

BarNone is a lightweight, eye-friendly, and feature-rich terminal progress bar. (The best bar, no contest)

## Table of Contents

- [Features](https://github.com/nickstuer/barnone?tab=readme-ov-file#features)
- [Install](https://github.com/nickstuer/barnone?tab=readme-ov-file#install)
- [Usage](https://github.com/nickstuer/barnone?tab=readme-ov-file#usage)
- [Contributing](https://github.com/nickstuer/barnone?tab=readme-ov-file#contributing)
- [License](https://github.com/nickstuer/barnone?tab=readme-ov-file#license)

## Features

 - Clean, minimal visual output
 - Smooth gradient color transition (Red → Gold → Green)
 - ETA and step tracking
 - Fast render speed of ~200ns per iteration

## Install

```
# PyPI
pip install barnone
```
or
```
uv add barnone
```

## Dependencies
Python 3.9 or greater

## Usage

### Example
```python
from barnone import ColoredProgressBar
pb = ColoredProgressBar(5)
#pb = ProgressBar(total=5)

for _ in range(5):
    time.sleep(0.1)
    pb.update()
```

Terminal Output:
![ColoredProgressBar Example](screenshots/ColoredProgressBar.png "ColoredProgressBar Example")


## Contributing

PRs accepted.

If editing the Readme, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.

#### Bug Reports and Feature Requests
Please use the [issue tracker](https://github.com/nickstuer/barnone/issues) to report any bugs or request new features.

#### Contributors

<a href = "https://github.com/nickstuer/barnone/graphs/contributors">
  <img src = "https://contrib.rocks/image?repo=nickstuer/barnone"/>
</a>

## License

[MIT © Nick Stuer](LICENSE)