semvec/pypi-packages huggingface dataset:
raster-zonal-stats 0.1.2
A Python package to retrieve raster values for each pixel of a shapefile.
Requires Python: >=3.6

# Raster Zonal Stats

'Raster Zonal Stats' is a Python library designed to retrieve raster values for each pixel of a shapefile.

## Installation

Install using below pip command

```bash
pip install raster-zonal-stats

```

# Usage

from raster_zonal_stats import RasterZonalStats

RasterZonalStats('/path/to/shapefile.shp', '/path/to/raster.tif', aggr='mean')

# Parameters

shp_path (str): Path to the shapefile.

tiff_path (str): Path to the TIFF file.

aggr (str, optional): Aggregation method for zonal statistics. Defaults to 'mean'.
language-model-toolkit 0.1
A holisitic for interfacing with ollama and other llm hosts. Created mainly for private experimentation.


# Python Module for Conversational AI Interactions

This Python module, built around the `OllamaClient`, facilitates generating text completions and managing interactive chat sessions. It is designed to serve as a foundational tool for developers, researchers, and hobbyists who are exploring conversational AI technologies. The module provides a straightforward interface for sending prompts to a conversational AI model and receiving generated responses, suitable for a wide range of applications from chatbots to creative writing aids.

## Features

- **Sandbox Setup:** Automates the creation of a sandbox environment for safe and isolated operation.
- **Text Generation:** Supports sending individual prompts to the AI model and receiving text completions.
- **Interactive Chat:** Allows for dynamic chat sessions with the AI, enabling real-time conversation simulations.

## Getting Started

### Installation

Ensure Python 3.6+ is installed. Clone this repository and install the required dependencies to get started:

```bash
git clone https://github.com/yourusername/conversational-ai-module.git
cd conversational-ai-module
pip install -r requirements.txt
```

### Quick Start

Import the `OllamaClient` in your Python script to begin interacting with the conversational AI model:

```python
from interface.cls_ollama_client import OllamaClient

# Initialize the client
client = OllamaClient()

# Generate a single completion
response = client.generate_completion("Your prompt here.")
print(response)
```

### Running Interactive Chat

To engage in an interactive chat session, you can use the following pattern in your script:

```python
client = OllamaClient()

while True:
    user_input = input("Enter your prompt: ")
    response = client.generate_completion(user_input)
    print(response)
```

## Sandbox Environment

The module includes functionality to set up a sandbox environment, isolating your interactions and data. This is particularly useful for testing and development purposes.

### Setup Sandbox

Call `setup_sandbox()` before starting your session to prepare the environment:

```python
from your_module import setup_sandbox

setup_sandbox()
```

## Contributing

Contributions are welcome! Please feel free to submit pull requests, report bugs, or suggest features.

## License

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

## Acknowledgments

- Thanks to the developers and contributors who made this project possible.
- Special thanks to OpenAI for providing the API and support for conversational AI research and development.
bible-reference 1.2
This module implements classes that I have developed to parse and output Bible references.
Requires Python: >=3

# bible_reference
Parse, sort and pretty-print Bible references.

This module implements classes that I have developed to parse and
output Bible references. With some 3,000 years of literary history,
that’s not as simple a task as one might think, especially when
dealing with several languages. Rudimentary datafiles for English are
supplied, but the most detailed representation is for my native 
German.

**If you have any questions or suggestions, contact me at 
Diedrich Vorberg ‹[diedrich@tux4web.de](mailto:diedrich@tux4web.de)›!**

# Some introduction

## infofile.py

Information is stored in a special CSV-like textfile format documented
in the infofile.py.

## bible_reference.py

### bible_reference.Canon

A canon is the representation of an order of Biblical Books loaded
from a .canon (info-) file. 

There is an internal (default) naming-scheme for Biblical books that
consists of mostly tow-letter English abbreviations. That’s hardcoded
in the info-files, not so much in the Python code. The order
of the books in the .canon file will be the sort order of the books.
**These internal names are refered to throughout the code as a book’s `intid`.**

### bible_reference.BiblicalBook

Implement comparison (that is: sorting) of biblical books by canon
order.

### bible_reference.NamingScheme

Return an intid for a Biblical book and provide unified
human-readable representations.

### bible_reference.bible_reference_re()

Return a regular expression object matching Bible references that use
names from any of the naming schemes. Ordinals will not be checked
(“9.Cor” will match) nor key plausibility (meaning, ambigious naming
schemes will yield undefined results).

The resulting regex should match German („1.Kor 2,12“) and English
(1Cor 2:12) biblical references. **Your milage for English references
may vary, for it has not been tested extensively.**

### bible_reference.BibleReference

Here is where it all comes together. An instance is created using

```python
br = BibleReference(BiblicalBook("Jn"), 3, 16)
```

or

```python
from bible_reference import BibleReference
from bible_reference.naming_schemes import RGG, Luther84_abbr

br = BibleReference.parse("Joh 3,16", [ Luther84_abbr, RGG, ])
```

For represenration, the first naming scheme passed to the constructor
is used by default.


There is a directory postgresql/ containing example code on how to use
this for sorting biblical references in the a relational database in
canonical order. See [postgresql/README.md](postgresql/README.md)