semvec/pypi-packages huggingface dataset:
lunaengine 0.2.2
A modern 2D game engine with advanced UI and graphics
License: MIT
Requires Python: >=3.9
Keywords: game, engine, 2d, graphics, pygame

# LunaEngine 🚀

A modern, optimized 2D game engine built with Python and Pygame featuring advanced UI systems, procedural lighting, and embedded asset management.
This engine have features like OpenGL and OpenAL!

<b>PyGame Renderer is no longer supported, only OpenGL!</b>

## 📋 Features

| Feature | Description | Status |
|---------|-------------|---------|
| **Advanced UI** | Roblox Studio-like UI components | ✅ Functional |
| **OpenGL Rendering** | Hardware-accelerated graphics | ✅ Functional |
| **Performance Tools** | FPS monitoring, hardware detection | ✅ Functional |
| **Themes** | The engine have pre-built themes | ✅ Functional |
| **Filters** | We home a huge amount of filters for your game(Blur, Neon, ...) | ✅ Functional |
| **Lighting System** | Dynamic lights and shadows | 🔄 WIP |
| **Particle Effects** | Particle system | 🔄 WIP |
| **Image Embedding** | Convert assets to Python code | ⚠️ Useless |
| **Modular Architecture** | Easy to extend and customize | :) |

# Code Statistics
[See this file](https://github.com/MrJuaumBR/LunaEngine/blob/main/lunaengine/CODE_STATISTICS.md)

[TestPyPi](https://test.pypi.org/project/lunaengine/)

[PyPi](https://pypi.org/project/lunaengine/)

[Changelog](https://github.com/MrJuaumBR/LunaEngine/blob/main/changelod.md)

## 🚀 Quick Start

### Installation

```bash
# First of all, install python 3.9+ (Not tested on older versions)
# Then you can install either from pypy or testpypi
pip install lunaengine
pip install -i https://test.pypi.org/simple/ lunaengine
```

*Ignore*
```bash
# Install dependencies
pip install -r requirements.txt

# Run a basic example
python examples/ui_comprehensive_demo.py
```

## Requirements

### Core Dependencies (required):

```bash
pygame>=2.5.0
numpy>=1.21.0
PyOpenGL>=3.1.0
PyOpenGL-accelerate>=3.1.0
PyOpenAL
```

### Development Tools (optional):

```bash
black>=22.0.0
flake8>=4.0.0
pytest>=7.0.0
setuptools>=65.0.0
wheel>=0.37.0
twine>=4.0.0
```

## Build
```bash
# Make build
python -m build

# Check files
twine check dist/* 

# Upload testpypi
twine upload --config-file .pypirc --repository testpypi dist/*

# Upload PyPi
twine upload --config-file .pypirc --repository pypi dist/*
```

## OpenGL
- Require OpenGL 3.3+
- OpenGL come activated by default

## Network
ToDo

<picture>
  <source
    media="(prefers-color-scheme: dark)"
    srcset="
      https://api.star-history.com/svg?repos=MrJuaumBR/LunaEngine&type=Date&theme=dark
    "
  />
  <source
    media="(prefers-color-scheme: light)"
    srcset="
      https://api.star-history.com/svg?repos=MrJuaumBR/LunaEngine&type=Date
    "
  />
  <img
    alt="Star History Chart"
    src="https://api.star-history.com/svg?repos=MrJuaumBR/LunaEngine&type=Date"
  />
</picture>
agentmeter-sdk 0.1.0
Track LLM costs per user. Open source SDK for AgentMeter.
License: MIT
Requires Python: >=3.9

# AgentMeter SDK

Track LLM costs per user. The official Python SDK for [AgentMeter](https://agentmeter.com).

AgentMeter automatically tracks token usage across OpenAI and Anthropic API calls, attributes costs to individual users, and reports them to your AgentMeter dashboard.

## Installation

```bash
pip install agentmeter-sdk
```

With provider-specific extras:

```bash
pip install agentmeter-sdk[openai]
pip install agentmeter-sdk[anthropic]
pip install agentmeter-sdk[all]
```

## Quick Start

```python
import agentmeter

# Initialize before creating any LLM clients
agentmeter.init(api_key="am_live_xxx")

from openai import OpenAI
client = OpenAI()

# Wrap LLM calls with identify() to attribute usage to a user
with agentmeter.identify(user_id="user_123"):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello!"}],
    )
```

That's it. Token usage is automatically captured and sent to your AgentMeter dashboard.

## Usage

### Initialization

Call `agentmeter.init()` **before** creating any LLM client instances. This patches the OpenAI and Anthropic libraries to capture usage data.

```python
agentmeter.init(
    api_key="am_live_xxx",   # Required. Get this from your dashboard.
    enabled=True,            # Disable to turn off tracking (e.g. in tests).
    debug=False,             # Print events to console instead of sending them.
)
```

### Identifying Users

Use `identify()` as a context manager or decorator to associate LLM calls with a user:

```python
# Context manager
with agentmeter.identify(user_id="user_123"):
    response = client.chat.completions.create(...)

# Decorator
@agentmeter.identify(user_id="user_123")
def handle_request():
    return client.chat.completions.create(...)
```

You can optionally pass a `session_id` to group multiple LLM calls into a single session:

```python
with agentmeter.identify(user_id="user_123", session_id="sess_abc"):
    response = client.chat.completions.create(...)
```

### Supported Providers

| Provider   | Sync | Async | Streaming |
|------------|------|-------|-----------|
| OpenAI     | Yes  | Yes   | Yes       |
| Anthropic  | Yes  | Yes   | Yes       |

### Shutdown

Flush pending events before your process exits:

```python
agentmeter.shutdown()
```

## License

MIT