semvec/pypi-packages huggingface dataset:
tei-loop 0.3.1
Target, Evaluate, Improve: A self-improving loop for agentic systems
License: MIT
Requires Python: >=3.9
Keywords: agents, evaluation, improvement, llm, agentic-systems, self-improving

# TEI Loop

**Target, Evaluate, Improve** — a self-improving loop for agentic systems.

## Get Started

```bash
pip install tei-loop
```

```bash
python3 -m tei_loop your_agent.py
```

TEI does the rest:
- Finds your agent function automatically
- Generates a test query automatically
- Evaluates across 4 dimensions
- Applies targeted improvements
- Saves results to `tei-results/` folder (created next to your agent file)

> If `pip` is not found, use `pip3` instead.

## What TEI Creates

```
your_project/
  your_agent.py
  tei-results/           <-- created automatically
    run_20260218_071500.json
    latest.json
```

## Options

```bash
python3 -m tei_loop agent.py                             # Auto everything
python3 -m tei_loop agent.py --function my_func          # Pick specific function
python3 -m tei_loop agent.py --query "custom input"      # Custom test query
python3 -m tei_loop agent.py --retries 5                 # More improvement cycles
python3 -m tei_loop agent.py --verbose                   # Detailed output
```

## Python API

```python
import asyncio
from tei_loop import TEILoop

def my_agent(query: str) -> str:
    return result

async def main():
    loop = TEILoop(agent=my_agent)
    result = await loop.run("test query")
    print(result.summary())

asyncio.run(main())
```

## 4 Evaluation Dimensions

| Dimension | What it checks |
|---|---|
| **Target Alignment** | Did the agent pursue the correct objective? |
| **Reasoning Soundness** | Was the reasoning logical? |
| **Execution Accuracy** | Were tools called correctly? |
| **Output Integrity** | Is the output complete and accurate? |

## Two Modes

**Runtime** (default): Per-query improvement in seconds.

**Development**: Across many queries, permanent prompt improvements.

```python
results = await loop.develop(queries=[...], max_iterations=50)
```

## Works With Any Agent

Any Python callable. No framework lock-in: LangGraph, CrewAI, custom Python, FastAPI, anything.

## License

MIT
hypermedia 6.0.0
An opinionated way to work with html in pure python with htmx support.
License: MIT
Requires Python: >=3.9
Keywords: Extendable, FastAPI, HTML, HTML Templating, HTMX, Partial HTML

# Hypermedia

Hypermedia is a pure python library for working with `HTML`. Hypermedia's killer feature is that it is composable through a `slot` concept. Because of that, it works great with `</> htmx` where you need to respond with both __partials__ and __full page__ html.

Hypermedia is made to work with `FastAPI` and `</> htmx`, but can be used by anything to create HTML.

___
![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fthomasborgen%2Fhypermedia%2Fmain%2Fpyproject.toml)
___

**Documentation
[Stable](https://thomasborgen.github.io/hypermedia/) |
[Source Code](https://github.com/thomasborgen/hypermedia) |
[Task Tracker](https://github.com/thomasborgen/hypermedia/issues)**

## Features

* Build __HTML__ with python classes
* __Composable__ templates through a __slot__ system
* Seamless integration with __</> htmx__
* Fully typed and __Autocompletion__ for html/htmx attributes and styles
* Opinionated simple decorator for __FastAPI__
* Unlike other template engines like Jinja2 we have full typing since we never leave python land.

## The Basics

All html tags can be imported directly like:

```python
from hypermedia import Html, Body, Div, A
```

Tags are nested by adding children in the constructor:

```python
from hypermedia import Html, Body, Div

Html(Body(Div(), Div()))
```

Add text to your tag:

```python
from hypermedia import Div

Div("Hello world!")
```

use `.dump()` to dump your code to html.


```python
from hypermedia import Bold, Div

Div("Hello ", Bold("world!")).dump()
```

output

```html
<div>Hello <b>world!</b></div>
```

## Composability with slots

```python
from hypermedia import Html, Body, Div, Menu, H1, Div, Ul, Li

base = Html(
    Body(
        Menu(slot="menu"),
        Div(slot="content"),
    ),
)

menu = Ul(Li("home"))
content = Div("Some content")

base.extend("menu", menu)
base.extend("content", content)

base.dump()
```

output

```html
<html>
    <body>
        <menu>
            <ul><li>home</li></ul>
        </menu>
        <div>
            <div>Some content</div>
        </div>
    </body>
</html>
```

# Documentation

Head over to our [documentation](https://thomasborgen.github.io/hypermedia)

If you are using this for HTMX, then please read the [HTMX section](https://thomasborgen.github.io/hypermedia/htmx/) of the documentation
posthoganalytics 7.9.3
Integrate PostHog into any python application.
License: MIT
Requires Python: >=3.10

# posthoganalytics

> **Do not use this package.** Use [`posthog`](https://pypi.org/project/posthog/) instead.

```bash
pip install posthog
```

This package exists solely for internal use by [posthog/posthog](https://github.com/posthog/posthog) to avoid import conflicts with the local `posthog` package in that repository. It is an automatically generated mirror of `posthog` — same code, same versions, just published under a different name.

If you are not working on the PostHog main repository, you should never need this package. All documentation, issues, and development happen in [`posthog-python`](https://github.com/posthog/posthog-python).