semvec/pypi-packages huggingface dataset:
ayaiml 1.0.0
Automation-based AI model runner for Gemini, ChatGPT, Grok, Perplexity and Image models.
Requires Python: >=3.8

🚀 ayaiml — Automate Gemini, ChatGPT, Grok, Perplexity & Image Models (Web-based AI Automation Library)

ayaiml is a powerful Python library that automates real AI models directly from the web UI — including:

Google Gemini AI Mode

Google Gemini App

ChatGPT

Grok AI (xAI)

Perplexity

DeepAI Image Generator

This library uses Undetected ChromeDriver + Selenium automation to interact with the official web UI of each model — giving you zero-API-key access to real LLMs.

Perfect for:

Students

Developers

Researchers

Automation projects

No-API-key usage

✨ Features

📌 Zero API Key required

🌐 Works directly on web UI of LLMs

🤖 Supports 5 text models + image model

⚡ Fast and stable (Undetected ChromeDriver)

🧩 Easy unified API: llm.invoke("your prompt")

🧠 Compatible with LangChain LLM interface

📥 Installation
pip install ayaiml


(If not uploaded yet, install manually from source)

🧠 Supported Models
Model	Class Name	Description
Gemini AI Mode	GeminiAIMode	Google Search AI Mode
Gemini App	Gemini	Google Gemini App (full model)
ChatGPT	ChatGPT	ChatGPT Web (Free/GPT-4o mini)
Grok	Grok	xAI Model
Perplexity	Perplexity	Perplexity Web
DeepAI	Image	Text-to-Image generator
🚀 Usage
1️⃣ Gemini AI Mode
from ayaiml import GeminiAIMode

llm = GeminiAIMode()
print(llm.invoke("Explain quantum computing in simple language"))

2️⃣ Gemini (Full Model)
from ayaiml import Gemini

llm = Gemini()
response = llm.invoke("Write a poem about AI and humanity")
print(response)

3️⃣ ChatGPT Web
from ayaiml import ChatGPT

llm = ChatGPT()
print(llm.invoke("What is the future of programming?"))

4️⃣ Grok (xAI)
from ayaiml import Grok

bot = Grok()
print(bot.invoke("Tell me a dark joke (safe mode)."))

5️⃣ Perplexity AI
from ayaiml import Perplexity

px = Perplexity()
print(px.invoke("Who will win World Cup 2026?"))

6️⃣ Image Generator (DeepAI)
from ayaiml import Image

img = Image()
print(img.invoke("A futuristic city floating in clouds"))

📌 How It Works?

Opens a real Chrome browser (undetected)

Anti-bot evasion enabled

Fully bypasses navigator.webdriver

Sends your prompt

Waits for model response

Extracts the text

Returns result as plain text

Works even with free accounts.

⚠ Important Notes

This library uses web automation, not API requests

Requires Chrome installed

First response may take 10–20 seconds

Keep browser window open during execution

Some websites may change HTML structure (updates will fix)

📁 Project Structure
ayaiml/
 ├── __init__.py
 └── core.py
README.md

🤝 Contributing

Pull requests are welcome!
You can add new models, fix XPaths, or improve performance.

📜 License

MIT License
Feel free to use commercially.

⭐ Show Support

If you like this project:

⭐ Star the GitHub repo

📦 Install from PyPI

📝 Use & share it

🔥 Author

Ayush Kumar
sigplay 0.0.12
A retro-modern terminal music player
Requires Python: >=3.13
Keywords: audio, cli, music, player, terminal, textual, tui

# SIGPLAY

A terminal music player with a retro-modern vibe. Built with Python and Textual.

![Python 3.13+](https://img.shields.io/badge/python-3.13+-orange)
![License MIT](https://img.shields.io/badge/license-MIT-orange)

## What it does

- Plays music from your `~/Music` folder (MP3, WAV, OGG, FLAC)
- Keyboard-driven interface with vim-style navigation
- Real-time audio visualization
- **Floppy Mix**: AI-powered DJ mixing using natural language instructions

## What it looks like

<p align="center">
  <img alt="main-view" src="https://github.com/user-attachments/assets/ba4901ea-8a97-4f57-a808-5232c6063018" width="800" />
</p>


## Run

First, install [uv](https://docs.astral.sh/uv/getting-started/installation/) if you don't have it:

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

Then run:

```bash
uvx sigplay
```

That's all! No other things needed.

## Controls

| Key | Action |
|-----|--------|
| `j/k` | Navigate track list |
| `Enter` | Play selected track |
| `Space` | Play/Pause |
| `s` | Stop |
| `n/p` | Next/Previous track |
| `+/-` | Volume up/down |
| `m` | Mute |
| `r` | Shuffle |
| `f` | Floppy Mix (AI DJ) |
| `d` | Back to main view |
| `h` or `?` | Help |
| `q` | Quit |

## Floppy Mix

Press `f` to open the AI DJ mixer. Select tracks, write instructions in plain English, and let the AI create a mix.

Example instructions:
- "Mix these with smooth 4-second crossfades"
- "Boost the bass and add reverb"
- "Create a high-energy mix with compression"

Requires an [OpenRouter](https://openrouter.ai/keys) API key. You can set it as an environment variable or enter it when prompted:

```bash
export OPENROUTER_API_KEY="your-key-here"
export SIGPLAY_MIX_MODEL_ID="anthropic/claude-haiku-4.5"  # optional
```

## Requirements

- `uv` installed
- Audio files in `~/Music`

## License

MIT
pyDynamicRoutingUpdater 0.0.9
A Python library to modify and alter the routing table in according to configuration passed
Requires Python: >=3.9.0



<img src="./static-assets/DynamicRoutingUpdater.svg" alt="drawing" width="200"/>
<br>
<p>┻━┻ ︵ヽ(`Д´)ﾉ︵ ┻━┻ </p>
<br>

# Dynamic Routing-table updater (DRU)

Example of reference.json
```json
{
    "tableName": "direct",
    "adapter": [
        "enp1s0f0",
        "enp1s0f1"
    ]
}
```
`tableName` will be the table name the program will use to direct routes and rules against </br>
```adapter``` will be the interfaces you will split out from the main routing table</br>

When you or the service starts up DRU,
it will prepare the required data. <br>
After the data has been loaded, it will be ready to start. All this occurs within the init call.

When DRU gets the start call, it will do the following:
- Remove old DRU tables (based on the Table name passed)
- Find all occupied table ids
- Filter out occupied
- Define table id and name for all network adapters added
- Write the newly filtered and appended routing table

After DRU has started, and processed the routing table, it will start up DRUHook. <br>
This is a sub component of DRU, which is intended to watch the network interfaces assigned to DRU and perform routing changes on them.<br>

If you want to test DRU out, you can do the following
```python

from DynamicRoutingUpdater import DynamicRoutingUpdater
service = DynamicRoutingUpdater()
service.dryrun()

```
<strong style="color: red">NOTE!</strong> This <strong>WILL</strong> do modifications to your routing table! <br>
This will also change and modify your current routes, and <strong>WILL NOT BE RESTORED!</strong>

Usually a reboot is enough to get it recreated, as the code does not include persistance

# How to install
## Dependencies
```shell
net-tools
```


To install and start DRU
- Clone the project 
- Modify reference.json
 - `./install.sh` 

</br>
Make sure that you run the script with sudo or as root, as the script needs access. <br>

Or you can do the following:
```shell
curl -sSL -o install.sh https://raw.githubusercontent.com/iktdev-no/DynamicRoutingUpdater/master/install.sh && sudo bash install.sh
```
This will request you to define table name and select interface thrould selection.


<br>
A copy of your routing table will exist as:

```sh
/etc/iproute2/rt_tables.bak
```