semvec/pypi-packages huggingface dataset:
nbformat-types 0.1
Types for notebook formats.
Requires Python: >=3.11

``nbformat`` types
==================

Re-export TypedDict versions of (currently) nbformat schemas
``v3_0``, ``v4_0``\ —\ ``v4_5`` (the latter also as ``current``).

Usage:

..  code-block:: python

    from typing import cast, TYPE_CHECKING
    import nbformat
    if TYPE_CHECKING:
        from nbformat_types import Document  # currently v4

    with open("Notebook.ipynb") as f:
        doc = cast(Document, nbformat.read(f, 4))
polarsgrid 0.3.0
Expand grid functionality using Polars
Requires Python: >=3.11

# Polarsgrid

[![Continuous integration](https://github.com/vankesteren/polarsgrid/actions/workflows/main.yml/badge.svg)](https://github.com/vankesteren/polarsgrid/actions/workflows/main.yml) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/polarsgrid)

Tidyverse-style [`expand_grid()`](https://tidyr.tidyverse.org/reference/expand_grid.html) in a fast and efficient way using [Polars](https://pola.rs).

## Installation 

Install the package as follows:
```sh
pip install polarsgrid
```

or add it to your project using [uv](https://docs.astral.sh/uv) as follows:
```sh
uv add polarsgrid
```

## Usage

This package contains only a single function: `expand_grid()`.

```py
from polarsgrid import expand_grid
expand_grid(a=[1, 2], b=["x", "y"])
```
```
shape: (4, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪═════╡
│ 1   ┆ x   │
│ 2   ┆ x   │
│ 1   ┆ y   │
│ 2   ┆ y   │
└─────┴─────┘
```

Note that the first argument iteratest fastest, and the last argument iterates slowest in the cartesian product.

Should the grid become too big to hold in memory, you can choose to return a lazy table which can be stored on a disk efficiently:

```py
from polarsgrid import expand_grid_lazy
lgrid = expand_grid_lazy(
    sample_size=list(range(1000)), 
    condition=["a", "b", "c"], 
    iteration=list(range(500)), 
)
lgrid.sink_parquet("grid.parquet")
```

Additionally, for certain operations it might be nice to return the string columns as a categorical data type, and to add a row id:

```py
expand_grid(
    fruit=["apple", "banana", "pear"], 
    color=["red", "green", "blue"], 
    check=[True, False], 
    _categorical=True,
    _row_id=True,
)
```
```
shape: (18, 4)
┌────────┬────────┬───────┬───────┐
│ row_id ┆ fruit  ┆ color ┆ check │
│ ---    ┆ ---    ┆ ---   ┆ ---   │
│ i64    ┆ cat    ┆ cat   ┆ bool  │
╞════════╪════════╪═══════╪═══════╡
│ 0      ┆ apple  ┆ red   ┆ true  │
│ 1      ┆ banana ┆ red   ┆ true  │
│ 2      ┆ pear   ┆ red   ┆ true  │
│ 3      ┆ apple  ┆ green ┆ true  │
│ 4      ┆ banana ┆ green ┆ true  │
│ …      ┆ …      ┆ …     ┆ …     │
│ 13     ┆ banana ┆ green ┆ false │
│ 14     ┆ pear   ┆ green ┆ false │
│ 15     ┆ apple  ┆ blue  ┆ false │
│ 16     ┆ banana ┆ blue  ┆ false │
│ 17     ┆ pear   ┆ blue  ┆ false │
└────────┴────────┴───────┴───────┘
```
nexosapi 0.1.0
SDK for Nexos API
Requires Python: >=3.12

# NexosAI API SDK

A modern Python SDK for integrating with the NexosAI cloud service. Easily connect your applications to NexosAI's powerful API for conversational AI, image, and audio processing.

---

## Features

- Unified API for chat, image, and audio endpoints
- Tool-augmented chat (web search, RAG, OCR)
- Type-safe request/response models (Pydantic)
- Easy configuration via environment variables or `.env` file
- Extensible architecture for custom endpoints

---

## Installation

For users:

```bash
pip install nexosapi
```

For contributors (local development):

```bash
git clone https://github.com/kamilrybacki/nexos.api.git
cd nexos.api
task init-project
```

---

## Quick Start

```python
from nexosapi.api.endpoints import chat

params = {
    "model": "your-model-id",
    "messages": [{"content": "Hello, how are you?", "role": "user"}],
}
chat.completions.request.prepare(params)
chat.completions.request.with_search_engine_tool(options={"search_context_size": "medium"})
response = await chat.completions.request.send()
print(response.model_dump())
```

---

## Documentation

- [Installation](docs/installation.md)
- [Configuration](docs/configuration.md)
- [Usage Examples](docs/usage.md)
- [Domain Models](docs/domain-models.md)
- [Endpoints](docs/endpoints/chat-completions.md)
- [Developer Guide](docs/developer_guide.md)

---

## Contributing

See [Developer Guide](docs/developer_guide.md) for instructions on adding new endpoints and request builder methods.

---

## License

MIT
lumett 2.0.6
Multi-platform TinTin++ MUD client with scalable GUI
Requires Python: >=3.6
Keywords: mud client tintin++ gaming

# LumeTT - Multi-platform TinTin++ MUD Client

LumeTT is a sophisticated wrapper around TinTin++ that provides an enhanced MUD (Multi-User Dungeon) gaming experience with a scalable GUI and pre-configured settings.

## Features

- **Enhanced TinTin++ Integration**: Seamless wrapper around the powerful TinTin++ MUD client
- **Pre-configured Setup**: Ready-to-use configuration files and scripts
- **User-friendly**: Automatic setup and configuration management
- **Scalable GUI**: Optimized interface for different screen sizes
- **Cross-platform**: Works on any Linux distribution

## Installation

### From PyPI (Recommended)

```bash
pip install lumett
```

### Prerequisites

You'll need TinTin++ installed on your system:

```bash
# Ubuntu/Debian
sudo apt install tintin++

# Or install the enhanced version with Lua/Python support
pip install tintin-lua-py
```

## Usage

After installation, simply run:

```bash
lumett
```

On first run, LumeTT will:
1. Create a configuration directory in `~/.lumett`
2. Copy all necessary configuration files
3. Launch TinTin++ with the LumeTT configuration

## Configuration

LumeTT stores its configuration in `~/.lumett/`. You can customize:

- **Connection settings**: Modify MUD server connections
- **Scripting**: Add your own TinTin++ scripts
- **UI settings**: Customize colors, layouts, and more
- **Library files**: Extend functionality with additional modules

## Command Line Options

LumeTT accepts all standard TinTin++ command line options:

```bash
lumett [tintin++ options]
lumett -h                    # Show TinTin++ help
lumett mudserver.com 4000    # Connect directly to a MUD
```

## Directory Structure

```
~/.lumett/
├── lib/
│   ├── init.tin         # Main initialization script
│   ├── colors.tin       # Color definitions
│   └── filesystem.tin   # File system utilities
├── LICENSE              # License information
└── README.txt          # Additional documentation
```

## Requirements

- Python 3.6 or higher
- TinTin++ (automatically detected)
- Linux operating system

## License

GPL v2 - See LICENSE file for details

## Contributing

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

## Support

For issues and support:
- Create an issue on GitHub
- Check the TinTin++ documentation for advanced usage

## Changelog

### 2.0.5
- Initial PyPI release
- Automatic configuration setup
- Enhanced TinTin++ integration
- Cross-platform compatibility improvements
grc-macronizer 1.3.0
A macronizer for Ancient Greek
Requires Python: ==3.12.*

# A Macronizer for Ancient Greek

<img src="docs/media/macronizer.gif" width="300">

A macronizer geared towards batch macronizing corpora with machine-friendly markup, avoiding combining diacritics and everything that doesn't render in standard IDE and terminal fonts unless specifically asked for.

*Installation:*
- Create a virtual environment with Python 3.12. Nothing will work if you don't get this step right!
- After having initialized your venv, activate it and install the right version of spaCy, the dependency of odyCy, with `pip install spacy>=3.7.4,<3.8.0`.
- Navigate to `external/grc_odycy_joint_trf` and install odyCy locally with `pip install grc_odycy_joint_trf`, while making sure that you are still in the venv with Python 3.12 you created earlier. 
- Install the submodule `grc-utils` with `cd grc-utils` and `pip install .`.

And that's it! Start macronizing by running the notebook [here](macronize.ipynb).

If you have a plain text file you want to macronize, you can run it with `python main.py input_file output_file`.

Note that if you have a newer spaCy pipeline for Ancient Greek, it is easy to substitute it for odyCy. Indeed, the rest of the software has no legacy dependencies and should run with the latest python. 

# License
go-smp 0.1.1
Python bindings for the aws tool session-manager-plugin
Requires Python: >=3.13

# Python Go Session Manager Plugin 

Python bindings for AWS Session Manager Plugin.

## Usage

```python
import go_smp
import boto3

instance='i-1234567890abcdefg'

session = boto3.Session(profile_name='your-profile')
client = session.client('ssm')

ssm_session = client.start_session(
    Target=instance
)

go_smp.start_session(
    ssm_session["SessionId"],
    ssm_session["StreamUrl"],
    ssm_session["TokenValue"],
    f"https://ssm.{session.region_name}.amazonaws.com",
    "some-unique-id",
    instance
)
```

## Roadmap

- [ ] Implement more methods to support ssm-cli
- [ ] Add pipelines to build cross platforms
- [ ] Add some tests
ksim 0.2.10
A modular and easy-to-use framework for training policies in simulation.
Requires Python: >=3.11

<div align="center">
<h1>K-Sim</h1>
<p>Welcome to <code>ksim</code>, a modular and easy-to-use framework for training policies in simulation.</p>
<h3>
  <a href="https://url.kscale.dev/docs">Docs</a> ·
  <a href="https://url.kscale.dev/discord">Discord</a>
</h3>
<img src="./assets/policy.gif" alt="Policy" />
</div>

## Installation

To install the framework:

```
pip install ksim
```

Make sure to install [JAX](https://github.com/google/jax#installation) correctly for your hardware (CPU or GPU). We recommend using `conda` rather than `uv` to avoid compatibility issues with MuJoCo on macOS.

## Getting Started

We suggest getting started by following the [examples](examples/).

## Acknowledgements

Many of the design decisions in `ksim` are heavily influenced other reinforcement learning training libraries like [Mujoco Playground](https://github.com/google-deepmind/mujoco_playground), [Isaac Lab](https://isaac-sim.github.io/IsaacLab/main/index.html) and [Maniskill](https://github.com/haosulab/ManiSkill). In particular, we are very grateful to the Mujoco and MJX maintainers for building a great, cross-platform simulator, and we hope `ksim` will help contribute to making it the ecosystem standard.