semvec/pypi-packages huggingface dataset:
finalsa-dynamo-dao 0.1.1
An utils package for using dynamodb
License: MIT
Requires Python: >=3.10
Keywords: dynamodb

Dynamo Dao

## Description

This is a simple DynamoDB Dao that can be used to interact with DynamoDB. It is a simple wrapper around the AWS SDK for DynamoDB.

## Installation

```bash
pip install finalsa-dynamo-dao
```

## Usage

```python
from finalsa.dynamo.dao import DynamoDao

# Create a new model and its dao

class MyModelDao(DynamoDao):
    id:str
    name:str
    age:int
    created_at:datetime

class MyModelDao(DynamoDao):
    PK:str
    name:str
    age:int
    created_at:datetime
    ttl:int

# Create a mapper
def my_mapper(item:dict) -> MyModelDao:
    return MyModelDao(**item)

# Create a reverse mapper

def my_reverse_mapper(model:MyModelDao) -> dict:
    return model.dict()

```
archaeo-summarizer 2025.12.21192749
archaeo-summarizer extracts structured summaries from archaeological and historical texts, highlighting key findings and cultural developments for efficient research.
License: MIT
Requires Python: >=3.9

# archaeo_summarizer
[![PyPI version](https://badge.fury.io/py/archaeo-summarizer.svg)](https://badge.fury.io/py/archaeo-summarizer)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/archaeo-summarizer)](https://pepy.tech/project/archaeo-summarizer)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)


## Overview

A package designed to extract structured summaries from textual inputs related to archaeological and historical research. Users provide descriptive or analytical text, and the package generates concise, organized summaries that highlight key findings, cultural developments, or migration patterns.

## Features

* Process complex textual sources to transform narrative data into standardized, digestible formats
* Streamline the creation of structured insights from textual inputs
* Ensure privacy and data safety by only processing text
* Support effective data comparison and analysis across studies

## Installation

```bash
pip install archaeo_summarizer
```

## Usage

```python
from archaeo_summarizer import archaeo_summarizer

response = archaeo_summarizer(
    user_input="Text to process",
    llm=None,  # Optional: Provide a langchain llm instance to use
    api_key=None  # Optional: Provide an LLM7 api key if not using the default rate limits
)
print(response)
```

You can safely pass your own llm instance (based on https://docs.langchain.com/) if you want to use a different LLM.

```python
from langchain_openai import ChatOpenAI
from archaeo_summarizer import archaeo_summarizer

llm = ChatOpenAI()
response = archaeo_summarizer(llm=llm)
print(response)
```

or for example to use the anthropic https://docs.langchain.anthropic.com/

```python
from langchain_anthropic import ChatAnthropic
from archaeo_summarizer import archaeo_summarizer

llm = ChatAnthropic()
response = archaeo_summarizer(llm=llm)
print(response)
```

or google https://docs.langchain.google.com/

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from archaeo_summarizer import archaeo_summarizer

llm = ChatGoogleGenerativeAI()
response = archaeo_summarizer(llm=llm)
print(response)
```

The default rate limits for LLM7 free tier should be sufficient for most use cases of this package. If you need higher rate limits for LLM7, you can pass your own api key via environment variable LLM7_API_KEY or via passing it directly like `archaeo_summarizer(api_key="your_api_key")`. You can get a free api key by registering at https://token.llm7.io/.

## Credits

* Author: Eugene Evstafev
* Author Email: hi@eugene.plus
* GitHub: https://github.com/chigwell

## Issues

* GitHub Issues: https://github.com/chigwell/.../issues

## License

Please see [MIT] for license details.
termoot 0.1.1
A terminal-based multiplayer shooter game
License: MIT
Requires Python: >=3.10

# Termoot

A terminal-based multiplayer shooter game built with Python and curses.

## Features

- Single-player mode with AI opponent
- Smooth terminal-based graphics using Unicode characters
- WASD movement controls
- Spacebar to shoot
- Color support for player and enemy
- Win/loss detection with rematch option

## Installation

### From PyPI

```bash
pip install termoot
termoot
```

### From source

```bash
git clone https://github.com/TangoBeee/termoot.git
cd termoot
pip install -e .
termoot
```

## Controls

- **W/A/S/D**: Move up/left/down/right
- **Spacebar**: Shoot
- **ESC**: Quit in-game
- **Arrow Keys**: Navigate menu

## Requirements

- Python 3.10 or higher
- Terminal with Unicode support
- Color terminal (recommended)

## Development

```bash
# Clone the repository
git clone https://github.com/TangoBeee/termoot.git
cd termoot

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install in development mode
pip install -e .

# Run the game
termoot
```

## Project Structure

```
termoot/
├── main.py              # Entry point and lobby
├── game/
│   ├── constants.py     # Game constants
│   ├── state.py         # Game state management
│   └── loop.py          # Main game loop
├── entities/
│   ├── player.py        # Player logic
│   ├── enemy.py         # Enemy AI
│   └── bullet.py        # Bullet mechanics
├── world/
│   └── walls.py         # Map generation
├── ui/
│   ├── draw.py          # Rendering functions
│   ├── dialogs.py       # UI dialogs
│   └── lobby.py         # Menu screen
├── network/             # (Future) Multiplayer
└── audio/               # (Future) Sound effects
```

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
gitgo 1.0.6
A safe Git commit, versioning, and push helper with AI-assisted messages
License: MIT
Requires Python: >=3.9
Keywords: git, cli, commit, versioning, ai

# gitgo Release 1.0.2

**gitgo** is a command-line tool that helps you commit, version, and push Git
changes safely, with a clear review step and optional AI-assisted commit
messages.

If you often forget to write good commit messages, tag releases consistently,
or want a single, predictable command to finalize your work, gup is designed
for you.

---

## What problem does gup solve?

Many Git workflows break down at the same points:

- changes pile up without commits
- commit messages are rushed or inconsistent
- version tags are forgotten or misnumbered
- pushes happen without a final review

gitgo turns these scattered steps into a **single, guided release flow**.

---

## What gitgo does

When run inside a Git repository, `gitgo`:

- stages current changes
- proposes a clear commit message (optionally AI-assisted)
- enforces a clean, ≤72-character summary line
- determines the next version tag automatically
- shows a full review screen before committing
- creates the commit and annotated tag
- pushes both to the configured remote

Every step is visible. Nothing happens without confirmation.

---

## Why gitgo is different

gup is intentionally conservative.

- No history rewriting
- No hidden automation
- No background hooks
- No silent commits

It favors **clarity over cleverness** and **review over speed**.

---

## Requirements

- Python 3.9 or newer
- Git
- The `llm` CLI installed and configured (for AI commit messages)
- A non-bare Git repository

---

## Installation

### Using pip (recommended)

Install gup as a standard CLI tool:

    git clone git@github.com:appfeat/gitgo.git
    cd gitgo 
    pip install .

After installation, the `gitgo` command will be available on your PATH.

---

## Usage

From inside a Git repository:

    gitgo
OR
    python -m gitgo

That’s the entire interface.

gitgo will guide you through:
- identity confirmation (if needed)
- model selection (first run only)
- commit message review
- release confirmation

---

## Configuration

gitgo stores its settings in Git config:

- `gitgo.model`   – selected LLM model
- `gitgo.timeout` – AI request timeout (seconds)

These settings are repository-local and do not affect other projects.

---

## Typical use cases

- finishing a feature and creating a clean release commit
- maintaining consistent version tags
- solo development with better commit hygiene
- small teams that want predictable Git history

---

## Philosophy

gitgo is designed around a simple idea:

> Finishing work should feel deliberate, not rushed.

It aims to make the *last step* of development calm, reviewable, and reliable.

---

## License

MIT