semvec/pypi-packages huggingface dataset:
oha-shared 0.1.0
OHA shared package
Requires Python: <4.0,>=3.13

# OHA Shared SDK

A collection of shared utilities, patterns, and components for OHA applications.

## Installation

### From GitHub Packages

```bash
pip install --index-url https://pypi.pkg.github.com/your-org/simple/ oha-shared
```

### Using Poetry

```bash
poetry add oha-shared
```

## Usage

```python
from oha_shared.mediator import init_mediator
# Use the shared components in your application
```

## Development

1. Install dependencies: `poetry install`
2. Run linting: `poetry run ruff check src`
3. Build package: `poetry build`

## Publishing

The package is automatically published to GitHub Packages when a new release is created.
mlc-tools 0.4.1174
A tool to generate and translate C++ code to other languages from one code-base.
Requires Python: >=3.6

| ci       | Status                                                                                                                                      |
|----------|---------------------------------------------------------------------------------------------------------------------------------------------|
| Travis   | [![Build Status](https://travis-ci.org/mlc-tools/mlc-tools.svg?branch=#)](https://travis-ci.org/mlc-tools/mlc-tools)                   |

[Trello Board](https://trello.com/b/SOlh2xPb/mlctools)

### Simple using: ###


```
cd src
python main.py
```

### Configured launch: ###

**Parameters:**
```
    -h, --help      show this help message and exit
    -i              Path to classes configs. Default = ./config/
    -o              Out Path for classes. Default = ./out/
    -l              Used language. Supported cpp, py, php. Default = cpp
    -f              Used serialized format. Supported xml, json. Default = xml
    -side           To different side generation, used both, server, client. Default = both
    -data           Path to static data configs. Default = empty, conversion is not used
    -data_out       Out path for static data config. Default = empty
    -only_data      Flag for build only data xml. Default = no
    -protocols      Path to file with serialization protocols. Default = empty, default protocol is used
    -php_validate   Check PHP features on generate other languages. Default = yes
    -test_script    The path to the script to run the tests
    -use_colors     Using colors on outputting to the console
```

### Syntax: ###

```
class core/Request<RequestBase>
{
    Action action
    int int_data
    float float_data = 0
    function void some_function(){}
}
```

```class                            ``` - keyword

```core/                            ``` - The module. Used only for grouping classes into folders for c++ generation

```Request                          ``` - Name of the class

```RequestBase                 ``` - The inherited class. Multiple inheritance is not supported.

```{ ... }                          ``` - Body of the class or method

```int int_data                     ``` - Field of class *int_data* of integer type.

```int float_data                   ``` - Field of class *float_data* of float type with initialized.

```function void some_function(){}  ``` - Method of the class without body
mdsnake 0.4.4
Views markdown text inside of the terminal
Requires Python: >=3.10
Keywords: app, macOS, windows, linux, flatpak

![pylint rated 10.00/10](https://img.shields.io/badge/pylint-10.00-green)
![version 0.4.4](https://img.shields.io/badge/version-v0.4.4-green)

# mdsnake

A library with a cli, that can view markdown files, without having to commit to github. If you forget markdown syntax as well, it will help you with that!

# Compatibility

Works on Linux, macOS, and Windows which requires Python **3.10** and above

# Installing

```
pip install mdsnake
```

# Commands

Views the markdown file in your console

```
mdsnake view README.md
```

Views the markdown file on a localhost

```
mdsnake view README.md --web
```

Converts markdown files to html/pdf

**Note:** Setting a name is optional

```
mdsnake view README.md html --name output.pdf
mdsnake view README.md html --name output.pdf
```

Creates a table of markdown syntax so you don't forget

```
mdsnake syntax
```
autogen-kubernetes-mcp 0.6.1
MPC server provides code interpreter with kubernetes workload
Requires Python: >=3.10

# autogen-kubernete-mcp

autogen-kubernetes-mcp is an MCP(Model Context Protocol) server that acts as a Python code interpreter fully compatible with the python built-in tool of the gpt-oss model.

It is designed as a custom extension for autogen-kubernetes, enabling Python code execution inside a Kubernetes Pod with configurable runtime parameters.

This MCP server can be used in environments where code execution needs to be isolated, reproducible, and integrated with Kubernetes workloads.

## Installation & Usage

1. Install via `pip`

```bash
pip install autogen-kubernetes-mcp
```

2. Install via `uv`

```bash
uv pip install autogen-kubernetes-mcp
```

3. Run via `uvx`

```bash
uvx autogen-kubernetes-mcp commandline --namespace my-namespace --image python:3.11-slim
```

4. Run via Python module

```bash
python -m autogen_kubernetes_mcp commandline --namespace my-namespace --image python:3.11-slim
```

## Command-line Arguments

Command-line arguments are used when creating `PodCommandLineCodeExecutor`/`PodJupyterCodeExecutor` and MCP server.

`type` arguments: jupyter type creates `PodJupyterCodeExecutor` for python code executor tool.

MCP server have to run in same kubernetes cluster because `PodJupyterCodeExecutor` only uses service FQDN to connect jupyter server.

Not validated for non-text outputs yet.

```mermaid
flowchart LR
  subgraph K8sCluster["Kubernetes Cluster"]
    E[PodJupyterCodeExecutor]
    J[JupyterServerPod]
  end

  E --generate--> J
```

All the arguments are optional

|Argument|Description|Default|
|--|--|--|
|`type`|Code Executor type, commandline(stateless), jupyter(stateful) supported||
|`--host`|MCP server host address|`0.0.0.0`|
|`--port`|MCP server port|`8000`|
|`--kubeconfig`|Path to the kubeconfig file|`None`(auto-detected)|
|`--image`|Pod container image name|`None`|
|`--pod-name`|Pod name|(auto-generated)|
|`--timeout`|Code execution timeout(seconds)|`60`|
|`--workspace-path`|Path inside the container where scripts are stored|`/workspace`|
|`--namespace`, `-n`|Kubernetes namespace for Pod creation|`default`|
|`--volume`|Kubernetes volume to mount into the Pod/container, accepts YAML format string, YAML file path|`None`|
|`--pod-spec`|Custom Pod spec definition(YAML format string, YAML file path)|`None`|
|`--command`|Custom executor container command|`None`|
|`--args`|Custom executor container arguments|`None`|

## License

This project is licensed under the MIT License.
htmlmaster 0.0.5
Provides tools for making html.
Requires Python: >=3.12
Keywords: config

# htmlmaster
Provides tools for making html.

## Installation
```sh
$ pip install htmlmaster
```


## Usage
### Make an html table

```py
>>> from repo.htmlmaster import src as hm

>>> table = hm.HTMLTableMaker(index=[1, 2], columns=["foo", "bar"])
>>> table[0, 0] = "this"
>>> table[0, 1] = "is"
>>> table[1, 0] = "a"
>>> table[1, 1] = "table"

>>> table.make()
'<table class="main">\n<thead>\n<tr>\n<th>foo</th>\n<th>bar</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>this</td>\n<td>is</td>\n</tr>\n<tr>\n<td>a</td>\n<td>table</td>\n</tr>\n</tbody>\n</table>'
```

If you are using a jupyter notebook, you can run a cell like this:

```py
>>> table.show()
```
<table class="main">
<thead>
<tr>
<th>foo</th>
<th>bar</th>
</tr>
</thead>
<tbody>
<tr>
<td>this</td>
<td>is</td>
</tr>
<tr>
<td>a</td>
<td>table</td>
</tr>
</tbody>
</table>


### Make an html tree

```py
>>> tree = hm.HTMLTreeMaker("this")
>>> tree.add("is")
>>> tree.add("a")
>>> tree.get(-1).add("tree")

>>> tree.make()
'<ul class="main">\n<li class="m"><details open><summary>this</summary>\n<ul class="m">\n<li class="m"><span>is</span></li>\n<li class="m"><details open><summary>a</summary>\n<ul class="m">\n<li class="m"><span>tree</span></li>\n</ul>\n</details></li>\n</ul>\n</details></li>\n</ul>'
```

If you are using a jupyter notebook, you can run a cell like this:

```py
>>> tree.show()
```
<ul class="main">
<li class="m"><details open><summary>this</summary>
<ul class="m">
<li class="m"><span>is</span></li>
<li class="m"><details open><summary>a</summary>
<ul class="m">
<li class="m"><span>tree</span></li>
</ul>
</details></li>
</ul>
</details></li>
</ul>

## See Also
### Github repository
* https://github.com/Chitaoji/htmlmaster/

### PyPI project
* https://pypi.org/project/htmlmaster/

## License
This project falls under the BSD 3-Clause License.

## History
### v0.0.5
* Bugfix for the argument parsing of `HTMLTreeMaker.addspan()`.

### v0.0.4
* Fixed a bug occured when specifying `value=None` for `HTMLTreeMaker()`.

### v0.0.3
* New method for `HTMLTreeMaker`: `*.addspan()`, `*.addval()`.
* Removed methods from `HTMLTreeMaker`: `*.setstyle()`, `*.getstyle()`


### v0.0.2
* New methods for `HTMLMaker`: `*.setrootstyle()`, `*.getrootstyle()`, `*.setrootcls()`, `*.getrootcls()`.
* Removed methods from `HTMLMaker`: `*.set_maincls()`, `*.get_maincls()`.

### v0.0.1
* Initial release.
kozhindev-data-labeler 0.0.2
Пакет, содержащий класс для разметки данных, используя большие языковые модели
Requires Python: >=3.12
Keywords: kozhindev_datalaber classification llm

# Usage example
```python
from pydantic import BaseModel

from kozhindev_data_labeler import LLMClient
from kozhindev_data_labeler import LLMProcessor


class Step(BaseModel):
    explanation: str = Field(..., description="Объяснение промежуточного вывода")
    think: str = Field(..., description="Анализ промпта и предыдущего шага, согласование рассуждений")


class PredictLLm(BaseModel):
    steps: list[Step] = Field(..., description="Пошаговое рассуждение")
    message: str = Field(..., description="Краткий итог рассуждений")
    target: str = Field(..., description="Классификация отзыва")


llm_client = LLMClient(
    model='gpt-4o-mini',
    api_key='API_KEY',
    system_prompt='SYSTEM PROMPT'
    response_format=PredictLLm
)

llm_processor = LLMProcessor(model_client=llm_client)


llm_processor.run(
    'ОТЗЫВ',
    'Сделай классификацию отзыва. 1 - негативный, 0 - положительный'
)

print(f'Ответ от модели: {llm.result}')
llm_processor.token_info()  # Выведет информацию о потраченных токенах
```
fild-ui 0.1.10
Operate with Web UI using selenium and fild library
Requires Python: >=3.9

# fild-ui v 0.1.10

![Downloads](https://img.shields.io/pypi/dm/fild-ui.svg?style=flat)
![Python Versions](https://img.shields.io/pypi/pyversions/fild-ui.svg?style=flat)
![License](https://img.shields.io/pypi/l/fild-ui.svg?version=latest)
[![Build Status](https://github.com/elenakulgavaya/fild-ui/workflows/Tests/badge.svg)](https://github.com/elenakulgavaya/fild-ui/actions)
micromelon 1.2.0
A Python module to control Micromelon Robots over BLE, TCP, or Serial with a Raspberry Pi connected to the rover
Requires Python: >=3.8

![Micromelon Logo](https://micromelon-robotics.github.io/mm-pymodule/mm-logo.png)
# [Micromelon](https://www.micromelon.com.au) Python Module

This module provides an API for connecting and controlling [Micromelon Rovers](https://www.micromelon.com.au/rover.html?) and simulated rovers in the [Micromelon Robot Simulator](https://www.micromelon.com.au/simulator.html).  
The API is equivalent to what is available in the Micromelon Code Editor application.

## Installation

```
pip install micromelon
```

## Usage
After import you will need a reference to the RoverController
```python
from micromelon import *
rc = RoverController()
```
The RoverController object contains all the functionality for connection and control of the robot's state.  
At the start of any script that controls the rover you will need to connect and put the rover in a running state.
Once complete you will need to return the rover to the idle state and optionally you can end the Python program.
```python
rc.connectBLE(1) # Connects over Bluetooth to rover with ID of 1
rc.startRover() # Puts in running state

# Body of script controlling rover
# eg. Motors.write(20, 20, 1)

rc.stopRover() # Returns to idle state
rc.end() # Disconnects and end Python program
```
Full code examples available in the examples folder.

## Documentation

### Generating Documentation
Full API documentation available at [https://micromelon-robotics.github.io/mm-pymodule/](https://micromelon-robotics.github.io/mm-pymodule/)  

Documentation is generated through the python module pdoc3.  
Full documentation on pdoc [available here](https://pdoc3.github.io/pdoc/).

#### 1. Installing pdoc
Install pdoc through pip.  
Requires python 3.  
```
pip3 install pdoc3
```

#### 2. Generating HTML
```bash
pdoc --html --template-dir docs/pdoc_templates -o docs micromelon -f
```

#### 3. Running docs locally
You can run the documentation as a webserver on your local machine with:  
```
pdoc --http : micromelon
```
Then open `http://localhost:8080/` in a browser.

## Building

Get Python build tool
```
python -m pip install --upgrade build
```
Build package
```
python -m build
```

## Uploading
Install twine
```
python -m pip install --upgrade twine
```
Uploading
```
python -m twine upload dist/*
```
pyverbs 59.0
Python bindings for rdma-core
Requires Python: >=3.10


# pyverbs

This is a simple wrapper around [rdma-core](https://github.com/linux-rdma/rdma-core)
to allow building `pyverbs` as a Python package.

[https://github.com/linux-rdma/rdma-core/blob/master/Documentation/pyverbs.md](https://github.com/linux-rdma/rdma-core/blob/master/Documentation/pyverbs.md)