semvec/pypi-packages huggingface dataset:
eodc 2025.10.2
Python SDK for interacting with EODC services.
Requires Python: <3.13,>=3.10

# EODC SDK
![PyPI - Status](https://img.shields.io/pypi/status/eodc)
![PyPI](https://img.shields.io/pypi/v/eodc)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/eodc)

Python SDK for interacting with EODC services.

## Installation
Install the SDK with pip:

```
pip install eodc
```

## Usage
### Dask Clusters

```
from eodc import settings
from eodc.dask import EODCCluster

settings.DASK_URL = "<EODC dask gateway endpoint>"

cluster = EODCCluster()
```

### Function-as-a-Service (FaaS)
TODO


### Workspaces

A workspace is a an abstraction of a object storage container/bucket. It is used to store and retrieve data.

Workspaces are integrated with EODC products and services, such as the openEO EODC backend.

There is 2 basic types of workspaces which we distinguish between, EODC Workspaces and External Workspaces.

- External Workspaces: These are object-storage buckets/containers which the users has provisioned from a third-party or is hosting themselves. They can be registered at EODC services and used in much the same way as EODC Workspaces, just that the user retains full control over them.

- EODC (internal) Workspaces: These are object-storage buckets which the user has provisioned from specifically EODC. Below the abstraction of workspaces they are S3 Ceph buckets which the user has write/read/delete privileges on. EODC still owns these buckets, and they are basically leased storage space for the user to use with EODC services.

Workspace Adapters, the code for which can be found in the workspace module in this repository, are an easy for for interacting with workspaces, both external and internal.

They generalize across different object-storage providers/standards and are used across EODCs products for managing and linking workspaces to functionality.

The exact capabilities are outlined in the code.
evalia 0.0.1
Bayesian evaluation and ranking toolkit
Requires Python: <3.14,>=3.9
Keywords: bayesian, statistics, ranking, evaluation, machine learning, large language models

<div align="center">

# Evalia

`evalia` implements the Bayes@N framework introduced in [Don't Pass@k: A Bayesian Framework for Large Language Model Evaluation](https://arxiv.org/abs/2504.11651)

[![arXiv](https://img.shields.io/badge/arXiv-2504.11651-b31b1b.svg)](https://arxiv.org/abs/2504.11651)
[![PyPI version](https://img.shields.io/pypi/v/evalia.svg)](https://pypi.org/project/evalia/)
[![Python versions](https://img.shields.io/pypi/pyversions/evalia.svg)](https://pypi.org/project/evalia/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](#license)

</div>

---

## Installation

```bash
pip install evalia
```

Requires Python 3.9–3.13 and NumPy.

## Data and shape conventions

- Categories: encode outcomes per trial as integers in `{0, ..., C}`.
- Weights: choose rubric weights `w` of length `C+1` (e.g., `[0, 1]` for binary R).
- Shapes: `R` is `M x N`, `R0` is `M x D` (if provided); both must share the same `M` and category set.

## APIs

- `bayes.eval.bayes(R, w, R0=None) -> (mu: float, sigma: float)`
  - `R`: `M x N` int array with entries in `{0, ..., C}`
  - `w`: length `C+1` float array of rubric weights
  - `R0` (optional): `M x D` int array of prior outcomes (same category set as `R`)
  - Returns posterior estimate `mu` of the rubric-weighted performance and its uncertainty `sigma`.

- `bayes.eval.avg(R) -> float`
  - Returns the naive mean of elements in `R`. For binary accuracy, encode incorrect=0, correct=1.

- `bayes.utils.competition_ranks_from_scores(scores, tol=1e-12) -> list[int]`
  - Convert scores to competition ranks (1,2,3,3,5,…) with tie handling.


## How to use

```python

import numpy as np
from bayes.eval import bayes

# Outcomes R: shape (M, N) with integer categories in {0, ..., C}
R = np.array([
    [0, 1, 2, 2, 1],   # Item 1, N=5 trials
    [1, 1, 0, 2, 2],   # Item 2, N=5 trials
])

# Rubric weights w: length C+1. Here: 0=incorrect, 1=partial(0.5), 2=correct(1.0)
w = np.array([0.0, 0.5, 1.0])

# Optional prior outcomes R0: shape (M, D). If omitted, D=0.
R0 = np.array([
    [0, 2],
    [1, 2],
])

# With prior (D=2 → T=10)
mu, sigma = bayes(R, w, R0)
print(mu, sigma)      # expected ~ (0.575, 0.084275)

# Without prior (D=0 → T=8)
mu2, sigma2 = bayes(R, w)
print(mu2, sigma2)    # expected ~ (0.5625, 0.091998)

```


## Citing

If you use Evalia or Bayes@N, please cite:

```
@article{hariri2025dontpassk,
  title   = {Don't Pass@k: A Bayesian Framework for Large Language Model Evaluation},
  author  = {Hariri, Mohsen and Samandar, Amirhossein and Hinczewski, Michael and Chaudhary, Vipin},
  journal={arXiv preprint arXiv:2504.11651},
  year    = {2025},
  url     = {https://mohsenhariri.github.io/bayes-kit/}
}
```


## License

MIT License. See the `LICENSE` file for details.


## Support

- Documentation and updates: https://mohsenhariri.github.io/bayes-kit/
- Issues and feature requests: https://github.com/mohsenhariri/bayes-kit/issues
voxcmd 1.2.1
A powerful AI assistant and file manager for your terminal
Requires Python: >=3.8
Keywords: ai, assistant, cli, gemini, file-manager, terminal

# VoxCmd

A powerful AI assistant and file manager for your terminal, powered by Google Gemini 1.5 Flash.

## Features

- 🤖 **AI-Powered Assistant**: Chat with AI or get command suggestions
- 📁 **File Management**: Create, view, delete, and find files easily
- 🚀 **Natural Language Commands**: Describe what you want, get the right command
- 🎨 **Rich Terminal Output**: Beautiful formatting with Rich library
- ⚡ **Fast and Lightweight**: Built with Typer for optimal performance

## Installation

```bash
pip install voxcmd
```

## Quick Start

1. **Set your Gemini API key**:
   ```bash
   voxcmd set-api-key YOUR_GEMINI_API_KEY
   ```

2. **Start using VoxCmd**:
   ```bash
   # Ask the AI anything
   voxcmd ask "create a python file that prints hello world"
   
   # View files
   voxcmd view myfile.txt
   
   # Create files directly
   voxcmd create-file app.py --content "print('Hello World!')"
   ```

## Available Commands

- `voxcmd ask "your question"` - Ask the AI assistant anything
- `voxcmd set-api-key <key>` - Configure your Gemini API key
- `voxcmd create-file <path> --content "..."` - Create files with content
- `voxcmd view <filepath>` - Display file contents
- `voxcmd delete <path>` - Delete files or directories
- `voxcmd find <name>` - Find files by name
- `voxcmd open-path <path>` - Open files/directories in default application
- `voxcmd hello <name>` - Say hello (example command)
- `voxcmd goodbye` - Say goodbye

## Getting a Gemini API Key

1. Go to [Google AI Studio](https://makersuite.google.com/app/apikey)
2. Create a new API key
3. Use it with `voxcmd set-api-key YOUR_KEY`

## Development & Release Process

This project uses automated publishing to PyPI via GitHub Actions.

### For Maintainers

**Releasing a new version:**

1. Update the version number in `pyproject.toml`
2. Commit your changes: `git commit -am "Release v1.x.x"`
3. Create and push a version tag: 
   ```bash
   git tag v1.x.x
   git push origin v1.x.x
   ```
4. The GitHub Action will automatically build and publish to PyPI

**Manual Release:**
Alternatively, create a [GitHub Release](https://github.com/santhoshsharuk/voc-cmd/releases) and the package will be published automatically.

### Setting up PyPI Token (for maintainers)

The automated publishing requires a PyPI API token stored as a GitHub secret:

1. Go to [PyPI Account Settings](https://pypi.org/account/) → API tokens
2. Create a new token scoped to this project
3. In your GitHub repository, go to Settings → Secrets and variables → Actions
4. Create a new secret named `PYPI_API_TOKEN` with your token value

## License

MIT License - see LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.