semvec/pypi-packages huggingface dataset:
mensura 0.2.2
Unit converter using graph-based methods
Requires Python: >=3.13

# mensura

#### By *Albert Dow*

#### *A simple Python package for converting between units*

## Description

A lightweight and simple package for converting between units,
`mensura` uses a graph-based approach to determine the shortest
path to the desired unit.

Currently only supports basic length and time units.

## Usage

```python
from mensura import Converter
converter = Converter()
converter.convert(1.0, "km", "m")
```
robotframework-domretrylibrary 4.0.1
AI-powered smart locator with retry functionality for Robot Framework using OpenAI
Requires Python: >=3.7

# Robot Framework DomRetryLibrary

A Robot Framework library with AI-powered fallback for locator variables, enhancing test reliability by using OpenAI to dynamically generate element locators when primary locators fail.

## What's New in Version 4.0.0

- **Major improvement in reliability** with a complete redesign of XPath generation strategy
- New **ID-First approach** that prioritizes direct element selection using unique attributes 
- Simplified selectors that don't break with complex DOM structures or forms
- Optimized for modern web applications with dynamic and nested elements

## Installation

Install the library using pip:

```bash
pip install robotframework-domretrylibrary
```

## Usage

Import the library in your Robot Framework test file:

```robotframework
*** Settings ***
Library           SeleniumLibrary
Library           DomRetryLibrary
```

Define your locators and AI fallback descriptions:

```robotframework
*** Variables ***
${USERNAME_FIELD}      css=#username_id
${AI_USERNAME_FIELD}   the username input field
```

Use the AI fallback in your tests (either with variable name or resolved variable):

```robotframework
*** Test Cases ***
Login Test
    Open Browser    https://example.com    chrome
    # Both syntaxes work in version 3.1.0+
    AI Fallback Locator    Input Text    USERNAME_FIELD    myusername
    # OR directly use the resolved variable
    AI Fallback Locator    Input Text    ${USERNAME_FIELD}    myusername
    Close Browser
```

You can also use custom keywords with fallback:

```robotframework
*** Keywords ***
Wait And Input Text
    [Arguments]    ${locator}    ${text}    ${timeout}=10
    [Documentation]    Input text with AI fallback if the primary locator fails
    ${status}    ${error}=    Run Keyword And Ignore Error    Input Text    ${locator}    ${text}
    Run Keyword If    '${status}' == 'FAIL'    AI Fallback Locator    Input Text    ${locator}    ${text}
```

## How The New Selectors Work (v4.0.0+)

The library now uses a prioritized approach to find elements:

1. **ID-First**: If an element has an ID, use it directly: `//*[@id='login-button']`
2. **Test Attributes**: Look for testing-specific attributes: `//*[@data-test='username']`
3. **Form Attributes**: For inputs, use name/placeholder: `//*[@placeholder='Enter username']`
4. **Meaningful Classes**: Only if needed: `//*[contains(@class, 'login-button')]`

This approach is much more reliable than complex hierarchical selectors and works even in deeply nested DOM structures with forms and dynamic elements.

## API Key Setup

Store your OpenAI API key in a .env file or provide it when initializing the library:

```robotframework
*** Settings ***
Library    DomRetryLibrary    api_key=${OPENAI_API_KEY}
```

## License

MIT
bangtex 1.0.0
Unicode UTF-8 Bangla to Bangtex converter
Requires Python: >=3.6

# Bangtex

Unicode UTF-8 Bangla to Bangtex converter

This program will convert a unicode utf8 encoded Bangla source text file for TeX/LaTeX into bangtex format.

## Installation

```bash
pip install bangtex
```

## Usage

```bash
from bangtex import convert_text

bangla_text = "বাংলা টেক্সট"
bangtex_text = convert_text(bangla_text)
print(bangtex_text)
```
fal-ai-mcp-server 0.1.2
An MCP (Model Contex Protocol) Server to use the fal.ai APIs to generate images and videos. 
Requires Python: >=3.10
Keywords: mcp, server

# Fal AI MCP Server

An MCP (Model Context Protocol) server to use the fal.ai APIs to generate images and videos.
This is a barebones server that anyone can extend to use different fal.ai models and API endpoints.

## Usage

Install [uv](https://docs.astral.sh/uv/) and add the server to an MCP config using `uvx`:

```json
{
    "name": "fal-ai-mcp-server",
    "command": "uvx",
    "args": [
        "fal-ai-mcp-server"
    ],
    "env": {
        "FAL_KEY": "your-key",
        "SAVE_MEDIA_DIR": "path/to/save/images"
    }
}
```

or clone the repo and use `uv` with a directory:

```json
{
    "name": "fal-ai-mcp-server",
    "command": "uv",
    "args": [
        "--directory",
        "path/to/root/dir/",
        "run",
        "main.py"
    ],
    "env": {
        "FAL_KEY": "your-key",
        "SAVE_MEDIA_DIR": "path/to/save/images"
    }
}
```

## Development

### Testing

Clone the repo and use [mcp-client-for-testing](https://github.com/piebro/mcp-client-for-testing) to test the tools of the server.

```bash
uvx mcp-client-for-testing \
    --config '
    [
        {
            "name": "fal-ai-mcp-server",
            "command": "uv",
            "args": [
                "--directory", 
                "path/to/root/dir/", 
                "run", 
                "main.py"
            ],
            "env": {
                "FAL_KEY": "your-key",
                "SAVE_MEDIA_DIR": "path/to/save/images"
            }
        }
    ]
    ' \
    --tool_call '{"name": "echo_tool", "arguments": {"message": "Hello, world!"}}'
```

### Formatting and Linting

The code is formatted and linted with ruff:

```bash
uv run ruff format
uv run ruff check --fix
```

### Building with uv

Build the package using uv:

```bash
uv build
```

### Releasing a New Version

To release a new version of the package to PyPI, create and push a new Git tag:

1. Checkout the main branch and get the current version:
   ```bash
   git checkout main
   git pull origin main
   git describe --tags
   ```

2. Create and push a new Git tag:
   ```bash
   git tag v0.2.0
   git push origin v0.2.0
   ```

The GitHub Actions workflow will automatically build and publish the package to PyPI when a new tag is pushed.
The python package version number will be derived directly from the Git tag.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
skelmis-f1-fantasy 0.2.0
A performant, typed API for the Formula 1 Fantasy game .
Requires Python: >=3.13

F1 Fantasy API Client
---

A mildy janky implementation letting you browser the F1 fantasy data set. Certain values are guaranteed to be wrong and methods missing due to a lack of public methods. This is a best guess implementation, and I'd love any feedback.


### Basic Usage

- Navigate to https://fantasy.formula1.com
- Open dev tools for your browser (typically F12)
- Click `Network`
- Login
- Look for a request to `/services/session/login`
- Click `Response`
- Copy the value of `GUID` and `Token`.
- See below example.

```python
import os
import asyncio

from fantasy import Client, APIClient


async def main():
    """Shows your highest place in all your private leagues."""
    client = Client(
        APIClient(
            user_guid=os.environ["USER_GUID"],
            token=os.environ["TOKEN"],
        )
    )

    user_leagues = await client.get_user_leagues()
    for league in user_leagues.leagues:
        leaderboard = await client.get_private_league_leaderboard(league.league_id)
        ranks = [i.rank_in_league for i in league.teams_in_league]
        print(f"League: {leaderboard.league_name}\n\tBest rank: {max(ranks)}")


if __name__ == "__main__":
    asyncio.run(main())
```

### Further Usage

The class `fantasy.Client` exposes all the nice data models, however many are missing.

If you want full access, use `fantasy.APIClient` which implements significantly more but provides the data as the API does which is hard to work with.
hatch-pyside 0.5.5
A hatch plugin to build Pyside6 elements
Requires Python: >=3.9

# hatch-pyside

[![PyPI - Version](https://img.shields.io/pypi/v/hatch-pyside.svg)](https://pypi.org/project/hatch-pyside)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/hatch-pyside.svg)](https://pypi.org/project/hatch-pyside)

-----

## Table Of Contents
  * [Goal](#goal)
  * [Status](#status)
  * [Installation](#installation)
  * [Usage](#usage)
    * [Plugin](#plugin)
    * [GUI](#gui)
    * [Developer](#developer)
  * [Compatibility](#compatibility)
  * [Contributing](#contributing)
  * [License](#license)
## Goal

This is a hatch plugin able to automatically build the required Python files
from their associated Qt source file. For example, it will build a
`ui_MainWindow.py` file from a `MainWindow.ui` one.

Additionally, it installs `pyside-build`, a GUI tool to manage the
`proj_name.pyproject` file
that is used by `pyside6-project` (which is internally called by
`hatch-pyside`).

## Status

The plugin and the GUI are currently beta quality. They still lack real world
tests and a decent documentation.

Starting with the 0.5.4 version, the plugin provides explanatory messages if 
the underlying `pyside6-project` command fails.

## Installation

The installation only makes sense if you want to use the GUI script. For a 
simple plugin usage, the `hatchling` build backend will automatically install
the plugin.

```console
pip install hatch-pyside
```

## Usage

### Plugin

You only have to declare the plugin as a build dependency, and configure it
to declare the directories that contain the Qt source files to compile.

If they contain a configured `.pyproject` file you are done:

```toml
[build-system]
requires = ["hatchling", "hatch-pyside"]
build-backend = "hatchling.build"
#...
# Declare the source folder(s) to the pyside plugin
[tool.hatch.build.targets.wheel.hooks.pyside]
folders = ["src/foo"]
```

### GUI

If you install the package in your environment, you will gain access to the
`pyside-builder` GUI tool. It uses the plugin configuration to know what are the
directories of interest, and allow you to easily populate a `.pyproject` file

### Developer

If you want to modify `hatch-pyside`, you can either grab the source package
from PyPI, or better clone the GitHub repository:

```commandline
git clone https://github.com/s-ball/hatch-pyside.git
```

## Compatibility

`hatch-pyside` works fine with `PySide6` in versions 6.8.x . In the new 6.9,
`pyside6-project` has a dependency on `tomlkit` which is not correctly 
handled by the `pip` dependencies machinery. For that reason, the current 
version of `hatch-pyside` requires a version 6.8.x of `PySide6`.

## Contributing

I shall always be glad to receive issues or Pull Requests on GitHub. But as
I am the only maintainer, I cannot guarantee to react quickly to them. Please
feel free to contact me by mail if I do not answer quickly enough...

## License

`hatch-pyside` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
tados-sysnet 0.1.0
Táďos Sysnet API - Send files to other systems using Sysnet
Requires Python: >=3.8

Send files to other systems using Sysnet.

Example:
```py
import tados_sysnet as sn

username, password = "Kočička", "*******"

systemID = sn.login(username, password)
if not systemID:
    print("Invalid credentials!")
    exit(1)

for file in sn.getQueue(username, password):
    print(file)
```
blag 2.3.3
blog-aware, static site generator
Requires Python: >=3.10
Keywords: markdown, blag, blog, static site generator, cli

# blag

blag is a blog-aware, static site generator, written in [Python][].

* an example "deployment" can be found [here][venthur.de]
* online [documentation][] is available on https://readthedocs.org.

blag is named after [the blag of the webcomic xkcd][blagxkcd].

[python]: https://python.org
[blagxkcd]: https://blog.xkcd.com
[venthur.de]: https://venthur.de
[documentation]: https://blag.readthedocs.io/en/latest/


## Features

* Write content in [Markdown][]
* Good looking default theme:
  ![Blag Screenshot](blag/static/blag.png)
* Theming support using [Jinja2][] templates
* Generation of Atom feeds for blog content
* Fenced code blocks and syntax highlighting using [Pygments][]
* Integrated devserver
* Available on [PyPI][]

blag runs on Linux, Mac and Windows and requires Python >= 3.10

[markdown]: https://daringfireball.net/projects/markdown/
[jinja2]: https://palletsprojects.com/p/jinja/
[pygments]: https://pygments.org/
[pypi]: https://pypi.org/project/blag/


## Install

blag is available on [PyPI][], you can install it via:

```bash
$ pip install blag
```

On Debian or Ubuntu, you can also just install the Debian package:

```bash
$ sudo aptitude install blag
```


## Quickstart

```bash
$ pip install blag                  # 1. install blag
$ blag quickstart                   # 2. create a new site
$ vim content/hello-world.md        # 3. create some content
$ blag build                        # 4. build the website
```
mcp-server-database 0.1.4
将自然语言转化为sql语句
Requires Python: >=3.12

#### 简介
> 将用户的问题转化为SQL语句，然后执行SQL语句，返回结果。
 
#### 使用
```json
{
    "mcpServers": {
        "nltosql_agent": {
            "command": "uvx",
            "args": ["mcp-server-database"],
            "env": {
                "model": "模型名称",
                "api_key": "模型api_key",
                "base_url": "模型调用地址",
                "database": "数据库类型",
                "host": "数据库地址",
                "port": "数据库端口",
                "user": "数据库用户名",
                "password": "数据库密码",
                "dbname": "数据库名称"
            }
        }
    }
}
```