semvec/pypi-packages huggingface dataset:
stara-cpp 0.1.2
A* pathfinding algorithm implementation in C++
Requires Python: <4.0.0,>=3.12.0

# Stara C++

A C++ implementation of the A\* pathfinding algorithm with Python bindings using pybind11.

## Installation

```bash
pip install stara-cpp
```

## Requirements

- Python 3.12 or higher
- CMake 3.15 or higher
- C++17 compatible compiler
- Poetry (for Python dependency management)
- numpy

## Development

1. Clone the repository:

```bash
git clone https://github.com/valerius21/stara-cpp.git
cd stara-cpp
```

2. Create and activate a Poetry environment:

```bash
poetry install
poetry shell
```

3. Build and install the package:

```bash
pip install -e .
```

## Usage

### Python

```python
import numpy as np
from stara_cpp import load_maze, AStar

# Create a maze (0 = wall, ≥1 = passage)
maze = np.array([
    [1, 0, 1, 1, 1],
    [1, 1, 1, 0, 1],
    [0, 0, 1, 0, 1],
    [1, 1, 1, 0, 1],
    [1, 0, 1, 1, 1],
], dtype=np.int32)

# Load maze and create pathfinder
maze_ptr = load_maze(maze)
pathfinder = AStar(maze_ptr)

# Find path from (0,0) to (4,4)
start = (0, 0)
goal = (4, 4)

try:
    path = pathfinder.find_path(start, goal)
    if path is not None:
        print("Path found:", path)
    else:
        print("No path found!")
except RuntimeError as e:
    print("Error:", str(e))
```

## API Reference

### Python API

#### `load_maze(array: np.ndarray) -> Maze`

Loads a numpy array into a C++ Maze object.

- `array`: 2D numpy array where 0 represents walls and ≥1 represents passages
- Returns: Maze object

#### `class AStar`

A\* pathfinding implementation.

##### Methods:

- `__init__(maze: Maze)`: Initialize with a maze
- `find_path(start: Tuple[int, int], goal: Tuple[int, int]) -> Optional[List[Tuple[int, int]]]`: Find path from start to goal
- `manhattan_distance(pos1: Tuple[int, int], pos2: Tuple[int, int]) -> int`: Calculate Manhattan distance

### C++ API

#### `class Maze`

Represents the maze grid.

##### Methods:

- `isValid(int x, int y) -> bool`: Check if coordinates are within bounds
- `isWalkable(int x, int y) -> bool`: Check if position is walkable
- `getCellNeighbours(int x, int y) -> vector<tuple<int, int, int>>`: Get neighboring cells

#### `class AStar`

A\* pathfinding implementation.

##### Methods:

- `findPath(pair<int, int> start, pair<int, int> goal) -> optional<vector<pair<int, int>>>`: Find path
- `manhattanDistance(pair<int, int> pos1, pair<int, int> pos2) -> int`: Calculate heuristic

## Development

### Building from Source

1. Install development dependencies:

```bash
poetry install
```

2. Build in development mode:

```bash
poetry shell
pip install -e .
```

### Running Tests

Run the example script:

```bash
python example.py
```
lzprompt 0.0.1
Lazy prompt building and response parsing.
Requires Python: <4.0,>=3.11
Keywords: python

# lzprompt

[![Release](https://img.shields.io/github/v/release/lzkit/lzprompt)](https://img.shields.io/github/v/release/lzkit/lzprompt)
[![Build status](https://img.shields.io/github/actions/workflow/status/lzkit/lzprompt/main.yml?branch=main)](https://github.com/lzkit/lzprompt/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/lzkit/lzprompt/branch/main/graph/badge.svg)](https://codecov.io/gh/lzkit/lzprompt)
[![Commit activity](https://img.shields.io/github/commit-activity/m/lzkit/lzprompt)](https://img.shields.io/github/commit-activity/m/lzkit/lzprompt)
[![License](https://img.shields.io/github/license/lzkit/lzprompt)](https://img.shields.io/github/license/lzkit/lzprompt)

Lazy prompt building and response parsing.

- **Github repository**: <https://github.com/lzkit/lzprompt/>
- **Documentation** <https://lzkit.com/lzprompt/>
indexable-generator 1.0.1
Implement Sequence functionalities to python Generators.
Requires Python: >=3.7

# IndexableGenerator

Implement Sequence functionalities to python Generators.

These include getitem, index and length. Values are cached as they are consumed
from the generator.

## Examples:

    @IndexableGenerator.cast
    def gen():
        for x in range(10):
            yield x

    ig = gen()
    ig[3:6]  # (3, 4, 5)

    ig = IndexableGenerator((x for x in range(10)))
    ig[3:6]  # (3, 4, 5)
quickdrop-cli 0.1.4
A simple deployment tool for quickdrop.host with automatic resource bundling
Requires Python: >=3.6

# QuickDrop CLI

QuickDrop is a command-line tool that simplifies web deployment by automatically bundling and deploying HTML projects. It handles resource bundling, asset optimization, and versioning in one simple command.

## Features

- **One-Command Deployment**: Deploy your entire web project with a single command
- **Automatic Resource Bundling**: CSS and JavaScript files are automatically inlined
- **Asset Optimization**: Images in CSS are converted to data URIs
- **Version Management**: Track deployment versions with built-in versioning
- **Analytics**: View deployment statistics and page views
- **Rollback Support**: Easy rollback to previous versions if needed


## Installation

```bash
pip install quickdrop-cli
```

## Quick Start

1. Login to QuickDrop:
```bash
quickdrop login
```

2. Deploy your HTML file:
```bash
quickdrop push index.html
```

## Commands

- `quickdrop login` - Authenticate with QuickDrop
- `quickdrop push <file>` - Deploy an HTML file
- `quickdrop list` - List all deployments
- `quickdrop versions <site_hash>` - List versions for a deployment
- `quickdrop rollback <site_hash> <version>` - Rollback to a specific version

## Options

- `-v, --verbose` - Show detailed output during deployment
- `--help` - Show help message and exit

## Example

```bash
# Deploy an HTML file with verbose output
quickdrop push index.html -v

# List all versions of a deployment
quickdrop versions abc123

# Rollback to version 2
quickdrop rollback abc123 2
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.