semvec/pypi-packages huggingface dataset:
je-api-testka-dev 0.0.129
Requests Automation Framework
Requires Python: >=3.10

# APITestka
APITestka is a lightweight, cross‑platform framework for automated API testing. 
It supports HTTP/HTTPS, SOAP/XML, and JSON, with high‑performance request execution, 
detailed reporting, and flexible CLI scripting. 
Designed for speed and scalability, APITestka enables thousands of requests per second, 
integrates with mock servers and remote automation, 
and generates reports in multiple formats for easy analysis.

# Features
- Automated API request execution
- Data comparison for each request
- Pure CLI mode support for API testing
- Detailed request/response reporting
- HTTP/HTTPS support
- SOAP/XML support
- JSON support
- Report generation in JSON, HTML, and XML formats
- APITestka scripting capability
- High performance: thousands of requests per second
- Cross-platform (OS independent)
- Mock server integration
- Remote automation support
- Project and template management
- New: httpx client support
- Synchronous and asynchronous requests with httpx
- HTTP/2 request support


## Installation
> pip install je_api_testka


## Requires
- python 3.9 or later
array-api-compat 1.13.0
A wrapper around NumPy and other array libraries to make them compatible with the Array API standard
Requires Python: >=3.10

# Array API compatibility library

This is a small wrapper around common array libraries that is compatible with
the [Array API standard](https://data-apis.org/array-api/latest/). Currently,
NumPy, CuPy, PyTorch, Dask, JAX, ndonnx and `sparse` are supported. If you want
support for other array libraries, or if you encounter any issues, please [open
an issue](https://github.com/data-apis/array-api-compat/issues).

See the documentation for more details https://data-apis.org/array-api-compat/
uv-mcp-server 0.6.4
Bridge modern, reproducible Python environments with MCP agents. Diagnose, self-heal, and manage uv workflows
Requires Python: >=3.11

# uv-mcp 

[![geminicli.com: featured extension](https://img.shields.io/badge/geminicli.com-featured%20extension-5F55AF?style=for-the-badge&logoColor=white)](https://geminicli.com/extensions)
![Python](https://img.shields.io/badge/Python-3.10%2B-FFE873?style=for-the-badge&logo=python&logoColor=white)
![Gemini](https://img.shields.io/badge/Gemini-Powered-4285F4?style=for-the-badge&logo=google&logoColor=white)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](LICENSE)


A Model Context Protocol (MCP) server for `uv` - the fast Python package manager. `uv-mcp` provides environment diagnostics, repair capabilities, and dependency management through a Gemini CLI extension.

---

![](ext/uv_mcp_logo.png)

## Why uv-mcp?

### **Built for Modern Python**
- **Native uv integration** - Works seamlessly with uv.lock and pyproject.toml
- **PEP 668 compliant** - Respects externally-managed-environment restrictions
- **No global pollution** - All operations scoped to project environments

### **AI-Native Design**
- **MCP protocol** - Works with Claude Desktop, Claude Code, Gemini CLI
- **Natural language** - No command syntax to memorize
- **Context-aware** - Understands your project structure automatically

### **Production-Ready**
- **Deterministic** - Same diagnosis and fixes across all machines
- **CI/CD friendly** - Works in containers and managed environments
- **Auditable** - Clear logs of every operation

---

## Quick Start

### Installation

**For Gemini CLI** (Recommended):
```bash
gemini extensions install https://github.com/saadmanrafat/uv-mcp
```

**For Claude Desktop/Code**:
```bash
claude mcp add uv-mcp -- uv --directory /path/to/uv-mcp run uv-mcp
```

More installation options in the [full documentation](https://saadman.dev/uv-mcp/)

---

## Links

- **Documentation**: https://saadman.dev/uv-mcp/
- **GitHub**: https://github.com/saadmanrafat/uv-mcp
- **Demo Video**: https://www.youtube.com/watch?v=Tv2dUt73mM8
- **Featured On**: https://geminicli.com/extensions
- **uv Docs**: https://docs.astral.sh/uv/
- **MCP Spec**: https://modelcontextprotocol.io/

---

##  Community & Support

- **Issues**: [GitHub Issues](https://github.com/saadmanrafat/uv-mcp/issues)
- **Twitter/X**: [@saadmanrafat](https://twitter.com/saadmanrafat_)

---

<div align="center">

**Built by [Saadman Rafat](https://github.com/saadmanrafat)**



[Install Now](https://saadman.dev/uv-mcp/guides/installation/#installation) • [Read Docs](https://saadman.dev/uv-mcp/) • [Watch Demo](https://www.youtube.com/watch?v=Tv2dUt73mM8)

</div>
textual-chat 0.1.4
LLM chat for humans. AI in your Textual app in a few lines.
Requires Python: >=3.10
Keywords: ai, chat, llm, textual, tui

![Example](screenshot.png)

# textual-chat

**LLM chat for humans.** Add AI to your terminal app in a few lines of code.

```python
from textual.app import App, ComposeResult
from textual_chat import Chat

class MyApp(App):
    def compose(self) -> ComposeResult:
        yield Chat()

MyApp().run()
```

That's it. No configuration, no boilerplate.

## Features

- **Zero-config** - Auto-detects your LLM setup and just works
- **ACP agents** - Works with Claude Code, OpenCode, and custom agents
- **Function calling** - Decorate Python functions as tools
- **Fully customizable** - It's a Textual widget, style it however you want

## Install

```bash
uv add textual-chat
```

Or with pip: `pip install textual-chat`

For ACP agent support: `uv add textual-chat[acp]`

## Quick Start

Set an API key:

```bash
export ANTHROPIC_API_KEY=sk-ant-...  # or OPENAI_API_KEY
```

Then run:

```python
from textual.app import App, ComposeResult
from textual_chat import Chat

class MyApp(App):
    def compose(self) -> ComposeResult:
        yield Chat(
            model="claude-sonnet-4-20250514",  # Optional
            system="You are a helpful assistant.",  # Optional
        )

MyApp().run()
```

## Tools

Pass any [FastMCP](https://gofastmcp.com) tool directly:

```python
from fastmcp import FastMCP

mcp = FastMCP("My Tools")

@mcp.tool
def get_weather(city: str) -> str:
    """Get the weather for a city."""
    return f"72°F and sunny in {city}"

chat = Chat(tools=mcp.tools)
```

Or use the `@chat.tool` decorator for quick one-offs:

```python
chat = Chat()

@chat.tool
def search(query: str) -> str:
    """Search the web."""
    return results
```

## Examples

See the `examples/` folder for complete examples:

| Example | Description |
|---------|-------------|
| `basic.py` | Minimal chat app |
| `with_tools.py` | Function calling |
| `with_thinking.py` | Extended thinking (Claude) |
| `with_mcp.py` | MCP server tools |
| `custom_model.py` | Custom model and system prompt |
| `in_larger_app.py` | Sidebar integration with tools |
| `chatbot_modal.py` | Modal dialog pattern |
| `chatbot_sidebar.py` | Toggleable sidebar |
| `with_tabs.py` | Tabbed interface |
| `acp_chat.py` | ACP agent integration |

Run any example:

```bash
uv run examples/basic.py
uv run examples/acp_chat.py examples/echo_agent.py
```

## Configuration

```python
Chat(
    model="claude-sonnet-4-20250514",  # Model ID or agent command
    adapter="litellm",                  # "litellm" or "acp"
    system="You are a pirate.",         # System prompt
    temperature=0.9,                    # Response randomness
    thinking=True,                      # Extended thinking (Claude)
    tools=[fn1, fn2],                   # Tool functions
    cwd="/path/to/project",             # Working directory
    show_token_usage=True,              # Show token counts
    show_model_selector=True,           # Allow /model switching
)
```

## License

MIT

---

Built with [Textual](https://textual.textualize.io/) and [LiteLLM](https://litellm.ai/)
pytest-json-ctrf 0.3.6
Pytest plugin to generate json report in CTRF (Common Test Report Format)
Requires Python: >=3.9

# CTRF for pytest

Pytest implementation of Common Test Report Format (CTRF) for test results.  
Test report will be generated in JSON format.  
Test report can be used to prettify the report in GitHub Actions with [github-actions-ctrf](https://github.com/ctrf-io/github-actions-ctrf).  
Do not worry if report in GitHub does not appear immediately. It takes some time to process the report. 

## Features
- Generates JSON report
- Tested to work correctly with and without [pytest-xdist](https://pypi.org/project/pytest-xdist/)
- Tested to get browser name from [pytest-playwright](https://pypi.org/project/pytest-playwright/)
- Parametrized tests are supported and reported as 1 test with multiple retries

## Installation

```bash
pip install pytest-json-ctrf
```

## Usage

generate report.json file in the root directory of the project. File path is mandatory

```bash
pytest --ctrf report.json
```

## Json exampe

More info here: https://ctrf.io/docs/schema/examples

```json
{
  "results": {
    "tool": {
      "name": "jest"
    },
    "summary": {
      "tests": 3,
      "passed": 1,
      "failed": 1,
      "pending": 0,
      "skipped": 1,
      "other": 0,
      "start": 1706644023,
      "stop": 1706644043
    },
    "tests": [
      {
        "name": "User should be able to login",
        "status": "passed",
        "duration": 1200
      },
      {
        "name": "User profile information should be correct",
        "status": "failed",
        "duration": 800
      },
      {
        "name": "User should be able to logout",
        "status": "skipped",
        "duration": 0
      }
    ]
  }
}
```

## Report Example
![Example Image](./assets/report_example.png)

## Technical details
For future me and others who are interested in the technical details of the implementation.  
The main idea is to handle xdist plugin because without it collecting report is quite straightforward.  
By the example of putest-json-report plugin, I have learned that different plugins can be registered for the controller and workers node.  
The `pytest_runtest_logreport` hook in the controller node is used to collect the test results from all the nodes so other nodes can just add some details to the `TestReport` object.

## Credits

- https://ctrf.io/ -> nice data format
- https://github.com/numirias/pytest-json-report -> Source of inspiration and dealing with xdist sync
- https://github.com/testomatio/pytestomatio -> Source of inspiration for creating pytest plugins
- https://github.com/infopulse/Playwright-course-python -> The report will be used in the demo project as +1 report option

### Roadmap
- Add screenshots handling
- Add hooks for the report extension
mediafile 0.14.0
A simple, cross-format library for reading and writing media file metadata.
Requires Python: >=3.10

MediaFile: read and write audio files' tags in Python
=====================================================

.. image:: https://github.com/beetbox/mediafile/actions/workflows/main.yml/badge.svg?branch=master
    :target: https://github.com/beetbox/mediafile/actions

.. image:: https://img.shields.io/pypi/v/mediafile.svg
    :target: https://pypi.python.org/pypi/mediafile

MediaFile is a simple interface to the metadata tags for many audio file
formats. It wraps Mutagen_, a high-quality library for low-level tag
manipulation, with a high-level, format-independent interface for a common set
of tags.

.. _mutagen: https://github.com/quodlibet/mutagen

Synopsis
--------

MediaFile is available `on PyPI`_. Install it by typing ``pip install
mediafile``. It works on Python 3.10 or later. Then:

.. code-block:: python

    from mediafile import MediaFile

    f = MediaFile("Lucy.mp3")
    f.title
    "Lucy in the Sky with Diamonds"
    f.artist = "The Beatles"
    f.save()

.. _on pypi: https://pypi.python.org/pypi/mediafile

Documentation
-------------

See the `full documentation`_.

.. _full documentation: https://mediafile.readthedocs.io/

Authors
-------

MediaFile is part of the beets_ project. It was originally written by `Adrian
Sampson`_ and is now developed by the beets community. The license is MIT.

.. _adrian sampson: https://github.com/sampsyo

.. _beets: https://github.com/beetbox/beets

.. _mit: https://www.opensource.org/licenses/mit-license.php
pysqlcrypt 0.2.0
Python implementation of SQL Server's ENCRYPTBYPASSPHRASE and DECRYPTBYPASSPHRASE
Requires Python: >=3.9
Keywords: 3des, aes, decryptbypassphrase, decryption, encryptbypassphrase, encryption, mssql, sql-server

# pysqlcrypt

Python implementation of SQL Server's `ENCRYPTBYPASSPHRASE` and `DECRYPTBYPASSPHRASE` functions.

## Quick Start

```bash
pip install pysqlcrypt
```

```python
from pysqlcrypt import encrypt_by_passphrase, decrypt_by_passphrase, SQLCryptVersion

# Encrypt
ciphertext = encrypt_by_passphrase("passphrase", "plaintext", SQLCryptVersion.V2)

# Decrypt with auto-detection (recommended)
plaintext = decrypt_by_passphrase("passphrase", ciphertext, encoding="auto")
```

## API

### `encrypt_by_passphrase(passphrase, plaintext, version=V1, authenticator=None, *, encoding="utf-8")`

Returns encrypted bytes. Use `SQLCryptVersion.V1` for SQL Server 2008-2016, `SQLCryptVersion.V2` for 2017+.

### `decrypt_by_passphrase(passphrase, ciphertext, *, authenticator=None, encoding=None)`

Returns decrypted bytes, or str if `encoding` is specified. Accepts bytes or hex string (with or without `0x` prefix).

## Encoding Options

| Value | Behavior |
|-------|----------|
| `None` | Returns raw bytes |
| `"auto"` | Auto-detects UTF-16LE (NVARCHAR) vs UTF-8 |
| `"utf-8"` | Decodes as UTF-8 (VARCHAR) |
| `"utf-16-le"` | Decodes as UTF-16LE (NVARCHAR) |

## Version Reference

| Version | SQL Server | Algorithm |
|---------|------------|-----------|
| V1 | 2008-2016 | 3DES-CBC, SHA1 |
| V2 | 2017+ | AES-256-CBC, SHA256 |

## Notes

- Use `encoding="auto"` for mixed VARCHAR/NVARCHAR data
- The `authenticator` parameter embeds additional context data for verification
- Decryption auto-detects the version from the ciphertext header

## License

MIT

🍌