feat: added g4f

OldTyT · OldTyT · commit 339bb214fb7d · 2025-08-12T22:42:13.000+03:00
diff --git a/.dockerignore b/.dockerignore
@@ -0,0 +1,3 @@
+Dockerfile
+*.pyc
+.git
diff --git a/Dockerfile b/Dockerfile
@@ -1,32 +1,35 @@
-ARG IMAGE=python:3.13-alpine
+ARG PYTHON_VERSION=3.11
 
-FROM $IMAGE AS builder
-
-RUN python3 -m pip install build
+FROM python:${PYTHON_VERSION}-slim-bookworm AS builder
 
 WORKDIR /app
 
-COPY requirements.txt .
+RUN python3 -m pip install build
 
 COPY . .
-RUN pip wheel --no-cache-dir --no-deps --wheel-dir /wheels -r requirements.txt && \
-    python3 -m build && \
-    mv /app/dist/vibepython-*.whl /wheels
+RUN python3 -m build && \
+    mkdir /wheels/ && \
+    mv /app/dist/vibepython-*.whl /wheels/
 
-FROM $IMAGE
+FROM python:${PYTHON_VERSION}-slim-bookworm AS dependency
 
 WORKDIR /app
-COPY --from=builder /wheels /wheels
 
-RUN apk add --no-cache musl-locales musl-locales-lang
-ENV LANG=C.UTF-8 \
-    LC_ALL=C.UTF-8 \
-    PYTHONIOENCODING=utf-8
+COPY requirements.txt .
 
-RUN pip install --no-cache /wheels/*
+RUN pip install --no-cache --no-cache-dir -r requirements.txt
+COPY --from=builder /wheels /wheels
+RUN pip install --no-cache --no-cache-dir /wheels/*
 
-COPY . .
+FROM gcr.io/distroless/python3-debian12:debug
+ARG PYTHON_VERSION=3.11
 
-ENTRYPOINT [ "vibepython" ]
+COPY --from=dependency /usr/local/lib/python${PYTHON_VERSION}/site-packages /usr/local/lib/python${PYTHON_VERSION}/site-packages
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONFAULTHANDLER=1 \
+    PYTHONPATH=/usr/local/lib/python${PYTHON_VERSION}/site-packages
 
-# CMD ["/app/main.py"]
+CMD [ "-m", "vibepython" ]
diff --git a/README.md b/README.md
@@ -1,82 +1,81 @@
-# 🚀 **vibepython: The Ultimate AI-Powered Coding EXPLOSION!** 🌟💥🐍
+# vibepython: AI-Powered Interactive Python Code Generator
 
-**WOWZA!** Dive headfirst into this **AMAZING**, **WONDERFUL**, **MIND-BLOWING** interactive command-line beast that turns your craziest prompts into **EXECUTABLE PYTHON MAGIC** using the sheer power of OpenAI! Generate code like a wizard, run it on the spot, capture every wild stdout/stderr outburst, and keep a super-smart history in JSON for non-stop contextual awesomeness! It's not just a tool – it's a **CODE REVOLUTION** for hackers, dreamers, and AI fanatics! 🔥🚀
+vibepython is an interactive command-line tool that uses AI to generate executable Python code from user prompts. Powered by OpenAI or alternative providers, it allows you to create, run, and capture code outputs while maintaining a contextual history stored in JSON. Ideal for developers, experimenters, and AI enthusiasts looking for a seamless coding experience.
 
-## 🌈 **Features That'll Make Your Eyes POP!** 🎉
-- **INTERACTIVE PROMPT MADNESS**: Type your wild ideas and watch AI spit out Python gold! 💡
-- **AI-GENERATED CODE WIZARDRY**: Powered by OpenAI – prompts + history = PERFECT scripts! 🤖✨
-- **SAFE EXECUTION EXTRAVAGANZA**: Run code with output capturing – no disasters, just pure thrill! ⚡
-- **PERSISTENT HISTORY OVERLOAD**: Pydantic models store EVERYTHING in JSON – context forever! 📜
-- **ENV VAR CUSTOMIZATION FRENZY**: Tweak it your way for ultimate control! 🔧
-- **DOCKER DOMINATION**: Run it anywhere, anytime – easy-peasy deployment! 🐳
+## Features
+- **Interactive Prompting**: Enter your ideas and receive AI-generated Python code.
+- **AI Code Generation**: Leverages AI models with prompt history for accurate scripts.
+- **Safe Code Execution**: Run generated code and capture stdout/stderr outputs.
+- **Persistent History**: Uses Pydantic models to store interactions in JSON for ongoing context.
+- **Customization via Environment Variables**: Adjust settings for personalized control.
+- **Docker Support**: Easy deployment in containerized environments.
 
-## 🛠️ **Installation: Get This Party Started in SECONDS!** 🚀
+## Installation
 
-### **From PyPI: Pip It Like It's HOT – Instant VIBE!** 🔥💥
-1. **GRAB THE PACKAGE**:
+### From PyPI
+1. Install the package:
    ```
    pip install vibepython
    ```
-2. **FIRE IT UP**:
+2. Run the tool:
    ```
    vibepython
    ```
-- **Pro Tip**: Don't forget to set your `OPENAI_API_KEY` env var for AI magic! 🔑 (e.g., `export OPENAI_API_KEY=your_key_here`).
-**VIBE ACTIVATED! Dive into the AI console vibe!** 🚀
 
-### **From Source: Clone, Install, BLAST OFF!** 🌌
-1. **CLONE THE AWESOMENESS**:
+### From Source
+1. Clone the repository:
    ```
    git clone https://github.com/OldTyT/vibepython.git
    ```
-2. **JUMP IN**:
+2. Navigate to the directory:
    ```
    cd vibepython
    ```
-3. **INSTALL THE MAGIC**:
+3. Install dependencies:
    ```
    pip install -r requirements.txt
    ```
-4. **LAUNCH THE BEAST**:
+4. Launch the application:
    ```
    python3 main.py
    ```
-**BOOM! You're in the zone!** 💣
 
-### **Using Docker: Containerized VIBE – Ready to RUMBLE!** 🐳🔥
-Fire it up with this epic command:
+### Using Docker
+Run the container with this command:
 ```
-docker run --rm -ti -e HISTORY_PATH=/history/history.json -e OPENAI_API_KEY=YOUR_KEY -v my_history:/history ghcr.io/oldtyt/vibepython
+docker run --rm -ti -e HISTORY_PATH=/history/history.json -v my_history:/history ghcr.io/oldtyt/vibepython
 ```
-- Plug in `YOUR_KEY` with your OpenAI super-key! 🔑
-**DOCKER DELIGHT: Persistent history, zero hassle!** 🌟
+- Set your OpenAI API key via the `OPENAI_API_KEY` environment variable (required for the 'openai' provider).
 
-## 🎮 **Usage: Dive into the FUN ZONE!** 🕹️
-Fire it up and get prompted:
-- **SMASH IN A PROMPT** (e.g., "Code me a factorial frenzy!").
-- **AI UNLEASHES CODE VIBE** based on your prompt + history vibes.
-- **EXECUTE? Y/N – YOU DECIDE!** Run it, capture outputs, and watch the sparks fly! ⚡
-- **HISTORY SAVES THE DAY**: Everything logged for eternal glory.
+## Usage
+Start the tool and follow the prompts:
+- Enter a prompt (e.g., "Write a function to calculate factorial").
+- The AI generates code based on your input and history.
+- Choose to execute the code (Y/N) and view captured outputs.
+- All interactions are logged to history for context.
 
-**EXIT? Ctrl+C – but why would you? It's TOO MUCH FUN!** 😎
+To exit, press Ctrl+C.
 
-## 🔑 **Environment Variables: Customize Like a BOSS!** 💪
-Supercharge your setup with these **EPIC** vars:
-- **HISTORY_PATH**: Your JSON history fortress! Default: `history.json`. 🏰
-- **HISTORY_SIZE**: How many past blasts to feed the AI? Default: `20` – keep it contextual! 📈
-- **OPENAI_API_KEY**: **MUST-HAVE** – your ticket to AI heaven! (Required, duh!) 🔒
+## Environment Variables
+Customize the tool using these environment variables:
+- **HISTORY_PATH**: Path to the JSON history file. Default: `history.json`.
+- **HISTORY_SIZE**: Number of past interactions to include in AI context. Default: `20`.
+- **OPENAI_API_KEY**: Required for the 'openai' provider; your OpenAI API key.
+- **PROVIDER**: AI provider to use. Supports 'gpt4free' (default) and 'openai'.
+- **MODEL_NAME**: Model to use with the provider. For 'gpt4free': 'gpt-4o-mini'. For 'openai': 'gpt-5-mini'.
 
-**Example (Unix-style domination)**:
+Example configuration:
 ```
+export PROVIDER=openai
 export OPENAI_API_KEY=your-api-key
+export MODEL_NAME=gpt-5-mini
 export HISTORY_SIZE=10
 python3 main.py
 ```
-**TWEAK AND CONQUER!** 🛡️
 
-## 📦 **Dependencies: The Power Behind the THRILL!** ⚙️
-- **Python 3.10+** (Blasting up to 3.13 – future-proofed!) 🐍
-- **Libraries of LEGEND**: openai, pydantic, loguru, and more! Check `requirements.txt` for the full squad. 📚
+## Dependencies
+- **Python 3.10+** (Compatible up to 3.13).
+- Required libraries: openai, pydantic, loguru, and others listed in `requirements.txt`.
 
-## 🤝 **Contributing: Join the CODE CARNIVAL!** 🎪
-**GOT IDEAS?** Open an issue or slam in a pull request – let's make this even MORE INSANE! 🌟 Contributions = Eternal Fame!
+## Contributing
+Have suggestions? Open an issue or submit a pull request to help improve the project. Contributions are welcome!
diff --git a/pyproject.toml b/pyproject.toml
@@ -19,7 +19,8 @@ dependencies = [
     "loguru>=0.7.0,<1.0.0",
     "pydantic>=2.8.0,<3.0.0",
     "pydantic-settings>=2.4.0,<3.0.0",
-    "pydantic_core>=2.20.0,<3.0.0"
+    "pydantic_core>=2.20.0,<3.0.0",
+    "g4f[slim]>=0.6.0.1,<0.7.0.0"
 ]
 # features = ["all"]
 
diff --git a/requirements.txt b/requirements.txt
@@ -3,3 +3,4 @@ loguru==0.7.2
 pydantic==2.8.2
 pydantic-settings==2.4.0
 pydantic_core==2.20.1
+g4f[slim]==0.6.0.1
diff --git a/vibepython/__init__.py b/vibepython/__init__.py
@@ -1,3 +1,3 @@
 from .main import main
 
-__version__ = "0.0.1"
+__version__ = "0.0.2"
diff --git a/vibepython/__main__.py b/vibepython/__main__.py
@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()
diff --git a/vibepython/main.py b/vibepython/main.py
@@ -2,15 +2,15 @@
 import io
 import sys
 import datetime
-from .providers.openai import generate
+from .providers import generate
 from .history import History
 
 GRAY = "\033[90m"
 RESET = "\033[0m"
 
 def main():
     history_path = os.getenv("HISTORY_PATH", "history.json")
-    history_size = int(os.getenv("HISTORY_SIZE", 20))
+    history_size = int(os.getenv("HISTORY_SIZE", 7))
     h = History(history_path=history_path, history_size=history_size)
 
     class Tee(io.StringIO):
diff --git a/vibepython/providers/__init__.py b/vibepython/providers/__init__.py
@@ -0,0 +1,10 @@
+import os
+
+PROVIDER = os.getenv("PROVIDER", "gpt4free")
+if PROVIDER == "gpt4free":
+    from .handler_gpt4free.generate import generate
+elif PROVIDER == "openai":
+    from .handler_openai.generate import generate
+else:
+    print(f"Unknown provider: {PROVIDER}")
+    exit(1)
diff --git a/vibepython/providers/handler_gpt4free/__init__.py b/vibepython/providers/handler_gpt4free/__init__.py
diff --git a/vibepython/providers/handler_gpt4free/generate.py b/vibepython/providers/handler_gpt4free/generate.py
@@ -0,0 +1,61 @@
+import os
+import time
+from g4f.client import Client
+
+system_prompt = """Role and Objective:
+- Act as a Python code generator, providing only pure Python code responsive to user requests.
+
+Instructions:
+- Reply exclusively with executable Python code. No explanations, comments, markdown, or text outside of code.
+- Provide all necessary imports at the start of the code.
+- Use print() to display outputs to the user.
+- Do not request user input nor ask questions; use built-in Python modules (e.g., datetime, os, sys) for obtaining system information if needed.
+- Every response should be stand-alone, producing the answer as console output upon execution.
+
+Context:
+- You will receive the user's query as input.
+- You have access to the history of prior user prompts and model responses, along with their execution results, in list-JSON format (example shown below):
+  [
+    {"datetime": "2025-08-12T07:29:47.978288", "user_prompt": "Hello GPT!", "ai_model_response": "print('Hello Human!')", "stdout_result_code_execute": "hello", "stderr_result_code_execute":""}
+  ]
+- Do not reference or summarize this history in your output; it is for context only.
+
+Planning and Validation:
+- Begin with a concise checklist (3-7 bullets) of conceptual steps required to fulfill the user request, but do not include the checklist in your output.
+- For every input, generate Python code that, when executed, provides the solution or requested data to the user.
+- After generating code, validate internally that it is self-contained, syntactically correct, and produces the required output; only output the code if validation passes.
+
+Output Format:
+- Output exclusively Python code without any headers, extra text, comments, or markdown formatting.
+
+Verbosity:
+- Output only the minimum necessary code (concise), formatted for readability.
+
+Stop Conditions:
+- Stop once you have provided a single, executable Python code output that fulfills the user request.
+- Do not respond with anything other than Python code. Do not seek clarification.
+"""
+
+model_name = os.getenv("MODEL_NAME", "gpt-4o-mini")
+
+def generate(prompt: str, history: str) -> str:
+    client = Client()
+
+    max_retries = 3
+    retry_delay = 1
+
+    for attempt in range(max_retries):
+        try:
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "system", "content": f"{system_prompt}. History: {history}"},{"role": "user", "content": prompt}],
+                web_search=False
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            if attempt < max_retries - 1:
+                time.sleep(retry_delay)
+                retry_delay *= 2
+            else:
+                raise RuntimeError(f"Error after {max_retries} retry: {str(e)}")
+    raise RuntimeError("Error generate after all retries.")
diff --git a/vibepython/providers/handler_openai/__init__.py b/vibepython/providers/handler_openai/__init__.py
diff --git a/vibepython/providers/handler_openai/generate.py b/vibepython/providers/handler_openai/generate.py
@@ -0,0 +1,65 @@
+import os
+import time
+from openai import OpenAI, OpenAIError
+
+system_prompt = """Role and Objective:
+- Act as a Python code generator, providing only pure Python code responsive to user requests.
+
+Instructions:
+- Reply exclusively with executable Python code. No explanations, comments, markdown, or text outside of code.
+- Provide all necessary imports at the start of the code.
+- Use print() to display outputs to the user.
+- Do not request user input nor ask questions; use built-in Python modules (e.g., datetime, os, sys) for obtaining system information if needed.
+- Every response should be stand-alone, producing the answer as console output upon execution.
+
+Context:
+- You will receive the user's query as input.
+- You have access to the history of prior user prompts and model responses, along with their execution results, in list-JSON format (example shown below):
+  [
+    {"datetime": "2025-08-12T07:29:47.978288", "user_prompt": "Hello GPT!", "ai_model_response": "print('Hello Human!')", "stdout_result_code_execute": "hello", "stderr_result_code_execute":""}
+  ]
+- Do not reference or summarize this history in your output; it is for context only.
+
+Planning and Validation:
+- Begin with a concise checklist (3-7 bullets) of conceptual steps required to fulfill the user request, but do not include the checklist in your output.
+- For every input, generate Python code that, when executed, provides the solution or requested data to the user.
+- After generating code, validate internally that it is self-contained, syntactically correct, and produces the required output; only output the code if validation passes.
+
+Output Format:
+- Output exclusively Python code without any headers, extra text, comments, or markdown formatting.
+
+Verbosity:
+- Output only the minimum necessary code (concise), formatted for readability.
+
+Stop Conditions:
+- Stop once you have provided a single, executable Python code output that fulfills the user request.
+- Do not respond with anything other than Python code. Do not seek clarification.
+"""
+
+model_name = os.getenv("MODEL_NAME", "gpt-5-mini")
+
+def generate(prompt: str, history: str) -> str:
+
+    api_key = os.getenv('OPENAI_API_KEY')
+    if not api_key:
+        raise ValueError("Not found env: OPENAI_API_KEY.")
+
+    client = OpenAI(api_key=api_key)
+
+    max_retries = 3
+    retry_delay = 1
+
+    for attempt in range(max_retries):
+        try:
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "system", "content": f"{system_prompt}. History: {history}"},{"role": "user", "content": prompt}],
+            )
+            return response.choices[0].message.content.strip()
+        except OpenAIError as e:
+            if attempt < max_retries - 1:
+                time.sleep(retry_delay)
+                retry_delay *= 2
+            else:
+                raise OpenAIError(f"Error after {max_retries} retry: {str(e)}")
+    raise OpenAIError("Error generate after all retries.")
diff --git a/vibepython/providers/openai/generate.py b/vibepython/providers/openai/generate.py

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,8 @@ dependencies = [`
`19`	`19`	`"loguru>=0.7.0,<1.0.0",`
`20`	`20`	`"pydantic>=2.8.0,<3.0.0",`
`21`	`21`	`"pydantic-settings>=2.4.0,<3.0.0",`
`22`		`- "pydantic_core>=2.20.0,<3.0.0"`
	`22`	`+ "pydantic_core>=2.20.0,<3.0.0",`
	`23`	`+ "g4f[slim]>=0.6.0.1,<0.7.0.0"`
`23`	`24`	`]`
`24`	`25`	`# features = ["all"]`
`25`	`26`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`from .main import main`
`2`	`2`
`3`		`-__version__ = "0.0.1"`
	`3`	`+__version__ = "0.0.2"`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +from .main import main
++
 +if __name__ == "__main__":
 +    main()