semvec/pypi-packages huggingface dataset:
uniqfunc 0.1.3
Git-aware checker for globally unique Python function names + reuse suggestions for AI agents
License: MIT
Requires Python: >=3.12

# uniqfunc

A git-aware checker for AI-generated Python code that enforces repo-wide unique function names (blocking) and emits reuse candidates for agent review (non-blocking).

## Recommended agent loop (Codex)

1. Generate or modify code.
2. Run `uvx uniqfunc --format json`.
3. If exit code `1`, fix naming conflicts until clean.
4. If `reuse_suggestions` are present, consider reusing or refactoring existing functions.

## VS Code integration

Text output is VS Code-clickable because every diagnostic line begins with `path:line:col` (no leading spaces).

## Usage

```bash
uvx uniqfunc
```

Defaults ignore `main` and `cli`. Add more exclude patterns (repeatable regex):

```bash
uvx uniqfunc --exclude-name '^main$' --exclude-name '^cli$'
```

## Output examples

Text (duplicate):

```text
path/to/file.py:10:1 UQF100 duplicate function name 'foo' (also in other.py:42:1) signature=def foo(): also_signature=def foo():
```

Text (reuse suggestions):

```text
=== UNIQFUNC LLM REUSE SUGGESTIONS ===
src/timeutils.py:12:1 UQF200 reuse_candidate target=epoch_to_aware_datetime candidates=1 signature=def epoch_to_aware_datetime(epoch_seconds) -> datetime:
src/timeutils.py:5:1 UQF201 candidate_for=epoch_to_aware_datetime target_loc=src/timeutils.py:12:1 name=epoch_to_datetime score=0.83 signals=name_token_jaccard:0.66 signature:0.75 ast:0.90 signature=def epoch_to_datetime(epoch) -> datetime:
=== END UNIQFUNC LLM REUSE SUGGESTIONS ===
```

JSON:

```json
{
  "version": "0.1.3",
  "repo_root": "/abs/path",
  "naming_conflicts": [
    {
      "code": "UQF100",
      "name": "foo",
      "occurrence": {"path": "a.py", "line": 10, "col": 1},
      "first_seen": {"path": "b.py", "line": 42, "col": 1}
    }
  ],
  "reuse_suggestions": [
    {
      "target": {"path": "timeutils.py", "line": 12, "col": 1, "name": "epoch_to_aware_datetime"},
      "candidates": [
        {
          "path": "timeutils.py",
          "line": 5,
          "col": 1,
          "name": "epoch_to_datetime",
          "score": 0.83,
          "signals": {
            "name_token_jaccard": 0.66,
            "signature_score": 0.75,
            "ast_score": 0.90
          }
        }
      ]
    }
  ],
  "errors": []
}
```

## Notes

- Requires a git repo and uses `git ls-files` for file selection.
- No config by design.
lispium 0.4.0
A Symbolic Computer Algebra System
License: MIT
Requires Python: >=3.8
Keywords: cas, computer-algebra, symbolic-math, lisp, mathematics

# Lispium

A Symbolic Computer Algebra System written in Zig.

## Installation

```bash
pip install lispium
```

Or with uv:

```bash
uv pip install lispium
```

## Usage

After installation, the `lispium` command is available:

```bash
# Start the REPL
lispium repl

# Run a file
lispium run script.lspm

# Show version
lispium --version

# Show help
lispium --help
```

## Features

- **Symbolic Computation**: Work with symbolic expressions and variables
- **Calculus**: Differentiation, integration, Taylor series, limits
- **Linear Algebra**: Matrices, determinants, eigenvalues, linear systems
- **Algebra**: Polynomial operations, equation solving, factoring
- **Number Theory**: Prime testing, factorization, modular arithmetic
- **And much more**: Complex numbers, vectors, statistics, plotting

## Example

```lisp
; Differentiate x^3
(diff (^ x 3) x)  ; => (* 3 (^ x 2))

; Solve quadratic equation
(solve (- (^ x 2) 4) x)  ; => {2, -2}

; Matrix determinant
(det (matrix (1 2) (3 4)))  ; => -2
```

## Documentation

See the [GitHub repository](https://github.com/Tetraslam/lispium) for full documentation.

## License

MIT
maitai-python 1.2.30
Maitai SDK for Python
License: MIT

# Quickstart

Full docs can be found at https://docs.trymaitai.ai

## Installation

Install the Maitai SDK:

```bash
pip install maitai-python
```

## Implementation

Implementing Maitai into your application requires minimal code changes.

```python
import maitai

messages = [
    {"role": "system", "content": "You are a helpful ordering assistant..."},
    {"role": "user", "content": "Generate a response to the customer..."},
]

response = maitai.chat.completions.create(
    messages=messages,
    model="llama3-70b-8192",  ## Remove this line to set model in Portal
    session_id="YOUR_SESSION_ID",
    intent="CONVERSATION",
    application="YOUR_APPLICATION_NAME",
)
```

**Note**
Maitai requires `openai` version `1.30.1` or later. If you are using an older version, please upgrade.

## Run Your Application

Run your application, make sure it makes at least one Chat Completion Request, then head over
to https://portal.trymaitai.ai and watch Maitai learn your application in real time.
yantra 0.7.1
A plugin framework
License: MIT
Requires Python: <3.13,>=3.12

# yantra

yantra is a simple plugin manager/plugin discovery framework.


## Usage

Let's assume you have a class called BaseReportPlugin which all report plugins derive from.

```python
from yantra import PluginManager, PluginType
from reports import BaseReportPlugin

# Define the type
report_type = PluginType(name='report',
                         base_class=BaseReportPlugin',
                         path='/plugins/reports/')

# Instantiate the manager
plugin_manager = PluginManager([report_type])

# Fetch plugins
plugin_manager.get_plugins(report_type)
```

You can register multiple plugin types. An alternate way to register plugin types is as follows:

```python
plugin_manager = PluginManager()
plugin_manager.register_plugin_type(foo_type)
```
gai-ag 2.0.0
A production-ready Python CLI tool for Google AI Studio.
License: MIT
Requires Python: >=3.10

# gai-ag (Gemini Autonomous Agent)

`gai-ag` is a professional, fast, and intelligent command-line tool that brings the Google Gemini API to your terminal. It features an advanced "Agent" mode that can both answer questions directly and perform automatic modifications on your project.

- **Autonomous Agent Mode**: Automatically fixes errors, runs tests, and generates solutions.
- **Project Brain**: Creates a `.gai/` folder in each project to store history, state, and errors.
- **Smart Scanning**: Caches project structure and prioritizes critical files to save tokens.
- **Polyglot Support**: Automatically detects Flutter, Node.js, and Python projects.

## ✨ Features

- 🤖 **Agent Mode**: Analyzes files in your project, plans requested changes (code writing, file creation, deletion, moving), and applies them with your approval.
- 💬 **Interactive Chat**: Communicate fluently with Gemini through a multi-modal chat interface.
- 📁 **Context Injection (@)**: Add files as context to your chat using `@file.py` or `@src/`.
- 🎨 **Premium UI**: Stylish and readable output powered by the `rich` library.
- 🌍 **Multi-language Support**: English and Turkish language options.
- 🔒 **Secure Operations**: File system operations are restricted to the project directory.

## 🚀 Installation

### From PyPI (Easiest)
```bash
pip install gai-ag
```

### For Development
1. Clone the repository:
   ```bash
   git clone https://github.com/bugraakdemir/gai-cli.git
   cd gai-cli
   ```

2. Install dependencies:
   ```bash
   pip install -e .
   ```

## 🛠️ Usage

> **Note**: Both `gai` and `gai-ag` commands work in the terminal!

### One-time Question
```bash
gai "What are list comprehensions in Python?"
# or
gai-ag "What are list comprehensions in Python?"
```

### Interactive Mode (Chat & Agent)
Start the interactive mode by simply typing `gai` or `gai-ag`:
```bash
gai
# or
gai-ag
```