semvec/pypi-packages huggingface dataset:
cq-ai 0.1.0
Current Quotient AI - Terminal-native AI coding agent, developed by CQ Team
License: MIT
Requires Python: >=3.10
Keywords: ai, coding, agent, cli, llm, cq, claude, terminal, developer-tools

# CQ-AI

**Terminal-native AI coding agent, developed by the CQ Team.**

CQ-AI (formerly ai-coder) is a powerful command-line tool that acts as your intelligent software engineering assistant. It integrates directly into your terminal, understands your codebase, and can plan, build, debug, and refactor code autonomously.

## Features

- 🖥️ **Interactive REPL** - Persistent `cq>` shell with slash commands
- 🤖 **Agentic Workflow** - Plan → Confirm → Execute → Verify
- 📁 **Repository Awareness** - Understands project structure and context
- ✏️ **Multi-File Editing** - Creates and modifies files with diff previews
- 🔧 **Tool Execution** - Runs builds, tests, and linters automatically
- 🛡️ **Safety Guards** - Prevents destructive actions without approval

## Installation

### Prerequisites
- Python 3.10+
- `pip` or `pipx`

### Install from source
```bash
git clone https://github.com/yourusername/cq-ai.git
cd cq-ai
pip install -e .
```

### Set up API key
Create a `.env` file in your project or set environment variables:
```bash
# For OpenAI (default)
export OPENAI_API_KEY=sk-your-key-here

# For Anthropic
export ANTHROPIC_API_KEY=sk-ant-your-key-here
```

## Usage

### Interactive Mode (Recommended)
Just type `cq` to enter the interactive REPL:

```bash
cq
```

You'll see the `cq-ai>` prompt. You can type natural language requests or use slash commands.

```text
cq-ai (my-project)> build a React login form
[Agent plans, creates files, and asks for confirmation]

cq-ai (my-project)> /debug the auth middleware
[Debugger agent analyzes and fixes issues]

cq-ai (my-project)> /help
```

### Slash Commands

| Command | Description |
|---------|-------------|
| `/build` | Interactive project builder |
| `/debug` | Find and fix bugs |
| `/review` | Code review and quality check |
| `/refactor`| Refactor code without changing behavior |
| `/plan` | Create implementation plan only |
| `/security`| Run security audit |
| `/test` | Test-driven development guide |
| `/fix` | Fix build/compile errors |
| `/config` | Run setup wizard |
| `/exit` | Exit the REPL |

### Single Command Mode
You can also run tasks directly from the shell without entering the REPL:

```bash
# Quick task
cq run "Add a dark mode toggle"

# Fix build errors
cq build-fix "npm run build"

# Security audit
cq security src/api/
```

## Configuration

Initialize configuration in your project:
```bash
cq init
```

Edit `.ai-coder/config.yaml`:
```yaml
llm:
  provider: "openai"  # openai, anthropic, huggingface, ollama, etc.
  model: "gpt-4o"
  temperature: 0.0

agent:
  max_iterations: 30
  auto_confirm: false
```

## License

MIT License
nssurge-api 1.0.1
NSSurge HTTP API for Python
License: MIT
Requires Python: >=3.11
Keywords: aiohttp, api, nssurge

# NSSurge Python API Client

Python implementation of the [Surge HTTP API spec](https://manual.nssurge.com/others/http-api.html) client using `aiohttp`.

You can use it to get/set Surge rules / policies / proxy groups, get recent requests / events and much more. 

This projects fully implements the [Surge HTTP API spec](https://manual.nssurge.com/others/http-api.html).

If you're looking for a command line tool to interact with your running Surge app, check out [NSSurge CLI](https://github.com/tddschn/nssurge-cli).

- [NSSurge Python API Client](#nssurge-python-api-client)
  - [Installation](#installation)
    - [pip](#pip)
  - [Usage](#usage)
  - [Develop](#develop)
  - [See also](#see-also)


## Installation

### [pip](https://pypi.org/project/nssurge-api/)

```
$ pip install nssurge-api
```

## Usage

```python
# source: https://github.com/tddschn/nssurge-cli/blob/master/nssurge_cli/cap_commands.py
from nssurge_cli.types import OnOffToggleEnum
from nssurge_api import SurgeAPIClient
from nssurge_api.types import Capability
import asyncio

async def get_set_cap(
    capability: Capability, on_off: OnOffToggleEnum | None = None
) -> bool | tuple[bool, bool]:
    """
    Get or set a capability
    """
    async with SurgeAPIClient(*get_config()) as client:
        state_orig = await get_cap_state(client, capability)
        match on_off:
            case OnOffToggleEnum.on | OnOffToggleEnum.off:
                await client.set_cap(capability, s2b(on_off))
            case OnOffToggleEnum.toggle:
                await client.set_cap(capability, not state_orig)
            case _:
                return state_orig
        state_new = await get_cap_state(client, capability)
        return state_orig, state_new
```

## Develop

```
$ git clone https://github.com/tddschn/nssurge-api.git
$ cd nssurge-api
$ poetry install
```

## See also

- [NSSurge CLI](https://github.com/tddschn/nssurge-cli): Command line Surge HTTP API Client built with this library
- [Surge HTTP API spec](https://manual.nssurge.com/others/http-api.html)
pingram-python 0.1.0
Official Python SDK for Pingram - Send notifications via Email, SMS, Push, In-App, and more
License: MIT
Requires Python: >=3.9
Keywords: pingram, notificationapi, notification, sdk, email, sms, push, in-app

# Pingram Python SDK

Official Python SDK for Pingram. Send notifications via Email, SMS, Push, In-App, and more from your server-side Python code.

## Requirements

- Python 3.9+
- Dependencies: `httpx`, `pydantic`, `python-dateutil`, `typing-extensions` (installed automatically)

## Installation

```bash
pip install pingram-python
```

To install from source (e.g. from the [GitHub repo](https://github.com/notificationapi-com/serverless)):

```bash
pip install -e sdks/python
```

## Quick start

Use the **Pingram** client with your **API key**, then call `send()` or the namespaced APIs (`user`, `users`, `logs`, etc.).

```python
import asyncio
from pingram import Pingram, SenderPostBody, SenderPostBodyTo

async def main():
    # API key (e.g. pingram_sk_...) or JWT; optional region ("us" | "eu" | "ca")
    async with Pingram(api_key="pingram_sk_...") as client:
        # Send a notification
        body = SenderPostBody(
            notification_id="your_notification_id",
            to=SenderPostBodyTo(id="user_123"),
        )
        response = await client.send(sender_post_body=body)
        print(response)

        # Or use namespaced APIs (same as Node: client.user, client.users, client.logs, ...)
        # user = await client.user.user_get_user(account_id="...", user_id="...")
        # logs = await client.logs.logs_query_logs(...)

asyncio.run(main())
```

You can also pass a config dict: `Pingram({"api_key": "pingram_sk_...", "region": "eu"})`. For full API coverage, use `client.send`, `client.user`, `client.users`, `client.logs`, `client.templates`, `client.environments`, and the other APIs.

## Links

- [Documentation](https://www.pingram.io/docs/)