API Documentation

Multiple Generation Functions

Implement different generation strategies based on your use case:

import requests
from typing import Optional, List

API_KEY = "sk_early_yourkey"
URL = "https://isomorfo.ai/api/generate"
PROMPT_SEP = "\n\n###\n\n"

class IsomorfoMultiGen:
    """Multiple code generation modes"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.sessions = {}  # History per session

    def _call_api(self, prompt: str, user_id: str = "default") -> str:
        """Base API call"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        data = {"prompt": prompt, "user_id": user_id}
        response = requests.post(URL, headers=headers, json=data)
        return response.json().get("result", "Error")

    # ========== MODE 1: SIMPLE GENERATION ==========
    def generate_single(self, prompt: str) -> str:
        """No history - each call is independent"""
        return self._call_api(prompt)

    # ========== MODE 2: SESSION GENERATION ==========
    def generate_with_session(self, prompt: str, session_id: str) -> str:
        """Maintains history per session"""
        if session_id not in self.sessions:
            self.sessions[session_id] = []

        # Concatenate history
        history = PROMPT_SEP.join(self.sessions[session_id])
        full_prompt = f"{history}{PROMPT_SEP}{prompt}" if history else prompt

        result = self._call_api(full_prompt, user_id=session_id)
        self.sessions[session_id].append(f"{prompt}{PROMPT_SEP}{result}")

        return result

    # ========== MODE 3: CHAIN GENERATION ==========
    def generate_chain(self, prompts: List[str], session_id: str = "chain") -> List[str]:
        """Execute multiple prompts in sequence, each sees the previous"""
        results = []
        for prompt in prompts:
            result = self.generate_with_session(prompt, session_id)
            results.append(result)
        return results

    # ========== MODE 4: ITERATIVE REFINEMENT ==========
    def refine(self, initial_prompt: str, refinements: List[str],
               session_id: str = "refine") -> str:
        """Generate initial code and refine iteratively"""
        # Clear session
        self.sessions[session_id] = []

        # Base code
        result = self.generate_with_session(initial_prompt, session_id)

        # Apply refinements
        for refinement in refinements:
            result = self.generate_with_session(refinement, session_id)

        return result

    # ========== MODE 5: SESSION FORK ==========
    def fork_session(self, source_id: str, new_id: str) -> None:
        """Copy history from one session to another (branching)"""
        if source_id in self.sessions:
            self.sessions[new_id] = self.sessions[source_id].copy()

    def clear_session(self, session_id: str) -> None:
        """Clear a specific session"""
        if session_id in self.sessions:
            del self.sessions[session_id]


# ========== USAGE EXAMPLES ==========
gen = IsomorfoMultiGen(API_KEY)

# MODE 1: Simple (no memory)
print(gen.generate_single("fibonacci function"))

# MODE 2: With session (memory per project)
print(gen.generate_with_session("Product class with price", "ecommerce"))
print(gen.generate_with_session("add apply_discount method", "ecommerce"))

# MODE 3: Prompt chain
results = gen.generate_chain([
    "create Calculator class",
    "add add method",
    "add subtract method",
    "add operation history"
], session_id="calc")

# MODE 4: Iterative refinement
final = gen.refine(
    "Basic REST API with Flask",
    [
        "add JWT authentication",
        "add input validation",
        "add error handling",
        "add logging"
    ]
)

# MODE 5: Branching (fork)
gen.fork_session("ecommerce", "ecommerce_v2")
print(gen.generate_with_session("add shopping cart", "ecommerce_v2"))