semvec/pypi-packages huggingface dataset:
stb-tester 34.10.0
Automated GUI testing for Set-Top Boxes
Requires Python: >=3.10

# Stb-tester

**Automated User Interface Testing for Set-Top Boxes & Smart TVs**

Copyright © 2018-2024 Stb-tester.com Ltd. All rights reserved.

This package contains the "stbt" Python APIs that you can use in test-scripts
written for running on the [Stb-tester Platform]. The primary purpose of this
package is to make the stbt library easy to install locally for IDE linting &
autocompletion.

This package doesn't support video-capture, so `stbt.get_frame()` and
`stbt.frames()` won't work -- but you will be able to run `stbt.match()` if you
specify the `frame` parameter explicitly, for example by loading a screenshot
from disk with `stbt.load_image()`.

This package doesn't include remote-control integrations, so `stbt.press()` and
similar functions won't work.

This package doesn't bundle the Tesseract OCR engine, so `stbt.ocr()` and
`stbt.match_text()` won't work.

Premium (non-open source) APIs, such as `stbt.get_rms_volume()` and other
audio-related APIs, are included as stubs to support IDE linting &
autocompletion, but without a working implementation.

[Stb-tester Platform]: https://stb-tester.com
stbt-core 34.10.0
Automated GUI testing for Set-Top Boxes
Requires Python: >=3.10

# Stb-tester open-source APIs (stbt_core)

**Automated User Interface Testing for Set-Top Boxes & Smart TVs**

* Copyright © 2013-2023 Stb-tester.com Ltd,
  2012-2014 YouView TV Ltd. and other contributors.
* License: LGPL v2.1 or (at your option) any later version (see [LICENSE]).

This package contains the `stbt_core` open-source Python APIs that you can use
in test-scripts written for running on the [Stb-tester Platform]. The primary
purpose of this package is to make the `stbt_core` library easy to install
locally for IDE linting & autocompletion.

This package doesn't support video-capture, so `get_frame()` and `frames()`
won't work -- but you will be able to run `match()` if you specify the `frame`
parameter explicitly, for example by loading a screenshot from disk with
`load_image()`.

This package doesn't include remote-control integrations, so `press()` and
similar functions won't work.

This package doesn't bundle the Tesseract OCR engine, so `ocr()` and
`match_text()` won't work.

[LICENSE]: https://github.com/stb-tester/stb-tester/blob/master/LICENSE
[Stb-tester Platform]: https://stb-tester.com
cflw 0.12.1
Control flow framework for running of state graphs
Requires Python: >=3.7

## cflw

A library for synchronously running nodes in a state graph.

Advantages: (envisaged)

* lean implementation
* customization towards production possible
* multi-developer scenario kept in mind

Code sketch:

    graph = Graph()
    graph.add_node(AllNodes.node1)
    graph.add_node(AllNodes.node2)
    graph.add_edge(AllNodes.node1, AllNodes.node2, entry_point=AllNodes.node1)
    state = CfState()
    ctx = CfCtx()
    rr = GraphRunner().run(graph, state, ctx)


This is a stub.


### Copyright, Disclaimer and License

See the LICENSE file contained in the package.
hackagames 0.2.5
An Hackable Games' Engine (python version)
Requires Python: >=3.8

# HackaGames - Several Shell-Based Hackable Games

**HackaGames** aims to be an open game engine dedicated to the development of Artificial Intelligence (AI) based on Operational Research (OR) technics.
The philosophy of **HackaGames** is to permit developers to easily work in any language of its choice.

The `pip` installed version relies on the python implémentation of the distributed engine : [hackapy](https://pypi.org/project/hacka). For a more complete version start from the source repository :  github: [www.github.com/ktorz-net/hackagames](https://www.github.com/ktorz-net/hackagames). 

- Documentation: [ktorz-net.github.io/hackagames](https://ktorz-net.github.io/hackagames).
nats-core 0.1.0
NATS core implementation in Python
Requires Python: >=3.13
Keywords: nats, messaging, client

# NATS Client

A Python client for the NATS messaging system.

## Features

- Support for publish/subscribe
- Support for request/reply
- Support for queue groups
- Support for multi-value message headers

## Installation

```bash
pip install nats-core
```

## Usage

```python
import asyncio
from nats.client import connect

async def main():
    client = await connect("nats://localhost:4222")

    # Subscribe
    async with await client.subscribe("foo") as subscription:
        # Publish
        await client.publish("foo", "Hello World!")

        # Receive message
        message = await subscription.next()
        print(f"Received: {message.data}")

    await client.close()

if __name__ == "__main__":
    asyncio.run(main())
```
kinisi 2.0.4
Efficient estimation of diffusion processes from molecular dynamics.
Requires Python: >=3.10

<picture>
  <source media="(prefers-color-scheme: light)" srcset="https://github.com/kinisi-dev/kinisi/blob/main/docs/source/_static/logo_light.png?raw=true">
  <source media="(prefers-color-scheme: dark)" srcset="https://github.com/kinisi-dev/kinisi/blob/main/docs/source/_static/logo_dark.png?raw=true">
  <img alt="The kinisi logo" src="https://github.com/kinisi-dev/kinisi/blob/main/docs/source/_static/logo_light.png?raw=true">
</picture>

Pronunciation: *kee-nee-see*

[![JCTC Status](https://img.shields.io/badge/JCTC-10.1021/acs.jctc.4c01249-blue.svg)](https://doi.org/10.1021/acs.jctc.4c01249)
[![JOSS Status](https://joss.theoj.org/papers/1ae102ffb6b3c63b04c002976440815d/status.svg)](https://joss.theoj.org/papers/1ae102ffb6b3c63b04c002976440815d)
[![PyPI version](https://badge.fury.io/py/kinisi.svg)](https://badge.fury.io/py/kinisi)
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/kinisi-dev/kinisi)

`kinisi` is an open-source package focussed on accurately quantifying the uncertainty in atomic and molecular displacements, and using this to more completely understand diffusion in materials.

## Installation

`kinisi` is available from the [PyPI](https://pypi.org/project/kinisi/) repository so can be installed using `pip` or alternatively `clone` [this repository](https://github.com/kinisi-dev/kinisi) and install the latest development build with the commands below.

```
pip install .
```

## Contributing

If you would like to contribute to `kinisi`, have a look at the [CONTRIBUTING.md](https://github.com/kinisi-dev/kinisi/blob/master/CONTRIBUTING.md) that outlines the different ways to help out.
shtym 0.2.0
AI-powered summary filter that distills any command's output.
Requires Python: >=3.10

# shtym

AI-powered summary filter that distills any command's output.

## Overview

Shtym is a command wrapper designed to reduce context size for both human users and AI coding agents. It wraps command execution and, when an LLM is available, summarizes the output; otherwise it passes output through unchanged.

## Installation

```bash
pip install shtym

# with Ollama support (requires a running Ollama instance)
pip install "shtym[ollama]"
```

## Configuration

### Basic Configuration (Environment Variables)

Configure Ollama settings using environment variables:

- `SHTYM_LLM_SETTINGS__BASE_URL`: Ollama server URL (defaults to `http://localhost:11434`)
- `SHTYM_LLM_SETTINGS__MODEL`: Model to use (defaults to `gpt-oss:20b`)

Example:

```bash
export SHTYM_LLM_SETTINGS__BASE_URL=http://localhost:11434
export SHTYM_LLM_SETTINGS__MODEL=llama2
stym run pytest tests/
```

### Advanced Configuration (Profiles)

For more control, create profiles in `~/.config/shtym/profiles.toml` with custom prompts and LLM settings:

```toml
[profiles.summary]
type = "llm"
system_prompt_template = "You are summarizing: $command"
user_prompt_template = "Output:\n$stdout"

[profiles.summary.llm_settings]
model_name = "gpt-oss:20b"
base_url = "http://localhost:11434"
```

Use profiles with the `--profile` option:

```bash
stym run --profile summary pytest tests/
```

See the [Profiles documentation](https://osoekawaitlab.github.io/shtym-py/profiles/) for more details.

## Usage

Wrap any command with `stym run`:

```bash
# Run tests
stym run pytest tests/

# Run linter
stym run ruff check .

# Build project
stym run npm run build

# Any command with options
stym run ls -la

# Pipe output to other commands
stym run pytest tests/ | grep FAILED
```

## Key Features

- **Exit code inheritance**: Shtym preserves the wrapped command's exit code, making it CI/CD friendly
- **Clean stdout**: Output contains only command results, no progress indicators or metadata
- **Transparent wrapper**: Works seamlessly with existing workflows and scripts
- **Optional LLM summaries**: If Ollama is available, output is summarized by the configured model; otherwise passthrough is used automatically

## Design Philosophy

Shtym follows Unix conventions for command wrappers (like `sudo`, `timeout`, `time`):

- Executes commands as subprocesses
- Inherits and propagates exit codes exactly
- Maintains clean stdout for composability
- Enables reliable integration with automated workflows

## Documentation

- [Profiles](https://osoekawaitlab.github.io/shtym-py/profiles/) - Advanced configuration with custom profiles
- [Roadmap](https://osoekawaitlab.github.io/shtym-py/roadmap/) - Planned features and enhancements

## Development

For development documentation, see:

- [Development Guide](https://osoekawaitlab.github.io/shtym-py/development/) - Setup, testing, and contribution guidelines
- [Architecture Overview](https://osoekawaitlab.github.io/shtym-py/architecture/overview/) - Design principles and ADRs

## License

MIT
lsegkd 0.1.0
A Python library for retrieving financial data using the LSEG Knowledge Direct API
Requires Python: >=3.12
Keywords: api, data, finance, lseg

# LSEG Knowledge Direct

[![Python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A Python library for retrieving financial data using the LSEG Knowledge Direct API.

## Features

- Authentication management for LSEG Knowledge Direct API
- Retrieve headlines, transcripts, and XML data
- Command-line interface (CLI)
- Structured JSON file output

## Installation

### From PyPI (recommended)

```bash
uv add lsegkd
```

or

```bash
pip install lsegkd
```

### Development Installation

```bash
git clone https://github.com/yurukatsu/lseg-knowledge-direct.git
cd lseg-knowledge-direct
uv sync --all-groups
```

## Usage

### Command Line Usage

Retrieve documents for a specified period and countries:

```bash
uv run lsegkd -d .env load-document --from_date 2025-11-22 --to_date 2025-11-23 --countries US --countries UK
```

### Authentication Setup

Set the following environment variables:

```bash
export LSEG_KNOWLEDGE_DIRECT_USERNAME="your_username"
export LSEG_KNOWLEDGE_DIRECT_APP_ID="your_app_id"
export LSEG_KNOWLEDGE_DIRECT_PASSWORD="your_password"
```

Alternatively, you can specify credentials directly using the Credentials class:

```python
from lsegkd.credentials import Credentials

credentials = Credentials(
    username="your_username",
    app_id="your_app_id", 
    password="your_password"
)
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.