|
|
""" |
|
|
Troviku-1.1 Python Client Library |
|
|
|
|
|
A comprehensive client for interacting with the Troviku-1.1 API. |
|
|
Supports code generation, code completion, and various programming tasks. |
|
|
""" |
|
|
|
|
|
import json |
|
|
import requests |
|
|
from typing import Optional, List, Dict, Any, Union |
|
|
from dataclasses import dataclass, asdict |
|
|
from enum import Enum |
|
|
|
|
|
|
|
|
class Language(Enum): |
|
|
"""Supported programming languages.""" |
|
|
PYTHON = "python" |
|
|
JAVASCRIPT = "javascript" |
|
|
TYPESCRIPT = "typescript" |
|
|
JAVA = "java" |
|
|
CPP = "cpp" |
|
|
RUST = "rust" |
|
|
GO = "go" |
|
|
RUBY = "ruby" |
|
|
PHP = "php" |
|
|
SWIFT = "swift" |
|
|
KOTLIN = "kotlin" |
|
|
CSHARP = "csharp" |
|
|
|
|
|
|
|
|
class TaskType(Enum): |
|
|
"""Supported task types.""" |
|
|
GENERATE = "generate" |
|
|
COMPLETE = "complete" |
|
|
EXPLAIN = "explain" |
|
|
REVIEW = "review" |
|
|
DEBUG = "debug" |
|
|
TRANSLATE = "translate" |
|
|
DOCUMENT = "document" |
|
|
TEST = "test" |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class GenerationConfig: |
|
|
"""Configuration for code generation.""" |
|
|
temperature: float = 0.7 |
|
|
top_p: float = 0.95 |
|
|
top_k: int = 50 |
|
|
max_tokens: int = 2048 |
|
|
stop_sequences: Optional[List[str]] = None |
|
|
frequency_penalty: float = 0.0 |
|
|
presence_penalty: float = 0.0 |
|
|
repetition_penalty: float = 1.1 |
|
|
|
|
|
def to_dict(self) -> Dict[str, Any]: |
|
|
"""Convert to dictionary, excluding None values.""" |
|
|
return {k: v for k, v in asdict(self).items() if v is not None} |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class CodeResponse: |
|
|
"""Response from the Troviku API.""" |
|
|
code: str |
|
|
language: str |
|
|
explanation: Optional[str] = None |
|
|
confidence: Optional[float] = None |
|
|
tokens_used: Optional[int] = None |
|
|
model_version: str = "1.1.0" |
|
|
|
|
|
@classmethod |
|
|
def from_api_response(cls, response: Dict[str, Any]) -> 'CodeResponse': |
|
|
"""Create CodeResponse from API response.""" |
|
|
content = response['choices'][0]['message']['content'] |
|
|
usage = response.get('usage', {}) |
|
|
|
|
|
return cls( |
|
|
code=content, |
|
|
language="auto-detected", |
|
|
tokens_used=usage.get('total_tokens'), |
|
|
model_version=response.get('model', '1.1.0') |
|
|
) |
|
|
|
|
|
|
|
|
class TrovikuClient: |
|
|
""" |
|
|
Client for interacting with the Troviku-1.1 API. |
|
|
|
|
|
Attributes: |
|
|
api_key: Your OpenTrouter API key |
|
|
base_url: Base URL for the API endpoint |
|
|
model: Model identifier |
|
|
""" |
|
|
|
|
|
DEFAULT_BASE_URL = "https://api.opentrouter.ai/v1" |
|
|
DEFAULT_MODEL = "OpenTrouter/Troviku-1.1" |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
api_key: str, |
|
|
base_url: str = DEFAULT_BASE_URL, |
|
|
model: str = DEFAULT_MODEL, |
|
|
timeout: int = 60 |
|
|
): |
|
|
""" |
|
|
Initialize the Troviku client. |
|
|
|
|
|
Args: |
|
|
api_key: Your OpenTrouter API key |
|
|
base_url: Base URL for API requests |
|
|
model: Model identifier to use |
|
|
timeout: Request timeout in seconds |
|
|
""" |
|
|
self.api_key = api_key |
|
|
self.base_url = base_url.rstrip('/') |
|
|
self.model = model |
|
|
self.timeout = timeout |
|
|
self.session = requests.Session() |
|
|
self.session.headers.update({ |
|
|
"Authorization": f"Bearer {api_key}", |
|
|
"Content-Type": "application/json" |
|
|
}) |
|
|
|
|
|
def generate( |
|
|
self, |
|
|
prompt: str, |
|
|
language: Optional[Union[str, Language]] = None, |
|
|
config: Optional[GenerationConfig] = None, |
|
|
system_prompt: Optional[str] = None |
|
|
) -> CodeResponse: |
|
|
""" |
|
|
Generate code based on a prompt. |
|
|
|
|
|
Args: |
|
|
prompt: Description of the code to generate |
|
|
language: Target programming language |
|
|
config: Generation configuration |
|
|
system_prompt: Optional system prompt for context |
|
|
|
|
|
Returns: |
|
|
CodeResponse containing generated code |
|
|
|
|
|
Raises: |
|
|
requests.exceptions.RequestException: On API errors |
|
|
""" |
|
|
if config is None: |
|
|
config = GenerationConfig() |
|
|
|
|
|
if isinstance(language, Language): |
|
|
language = language.value |
|
|
|
|
|
messages = [] |
|
|
|
|
|
if system_prompt: |
|
|
messages.append({"role": "system", "content": system_prompt}) |
|
|
elif language: |
|
|
messages.append({ |
|
|
"role": "system", |
|
|
"content": f"You are a code generation assistant. Generate {language} code." |
|
|
}) |
|
|
|
|
|
messages.append({"role": "user", "content": prompt}) |
|
|
|
|
|
payload = { |
|
|
"model": self.model, |
|
|
"messages": messages, |
|
|
**config.to_dict() |
|
|
} |
|
|
|
|
|
response = self._make_request("/chat/completions", payload) |
|
|
return CodeResponse.from_api_response(response) |
|
|
|
|
|
def complete( |
|
|
self, |
|
|
code: str, |
|
|
language: Optional[Union[str, Language]] = None, |
|
|
config: Optional[GenerationConfig] = None |
|
|
) -> CodeResponse: |
|
|
""" |
|
|
Complete partial code. |
|
|
|
|
|
Args: |
|
|
code: Partial code to complete |
|
|
language: Programming language of the code |
|
|
config: Generation configuration |
|
|
|
|
|
Returns: |
|
|
CodeResponse with completed code |
|
|
""" |
|
|
if isinstance(language, Language): |
|
|
language = language.value |
|
|
|
|
|
prompt = f"Complete the following {language or ''} code:\n\n```\n{code}\n```" |
|
|
return self.generate(prompt, language, config) |
|
|
|
|
|
def explain( |
|
|
self, |
|
|
code: str, |
|
|
language: Optional[Union[str, Language]] = None, |
|
|
detail_level: str = "medium" |
|
|
) -> str: |
|
|
""" |
|
|
Generate an explanation for given code. |
|
|
|
|
|
Args: |
|
|
code: Code to explain |
|
|
language: Programming language |
|
|
detail_level: Level of detail (low, medium, high) |
|
|
|
|
|
Returns: |
|
|
Explanation text |
|
|
""" |
|
|
if isinstance(language, Language): |
|
|
language = language.value |
|
|
|
|
|
prompt = f"""Explain the following {language or ''} code in {detail_level} detail: |
|
|
|
|
|
``` |
|
|
{code} |
|
|
```""" |
|
|
|
|
|
config = GenerationConfig(temperature=0.3) |
|
|
response = self.generate(prompt, language, config) |
|
|
return response.code |
|
|
|
|
|
def review( |
|
|
self, |
|
|
code: str, |
|
|
language: Optional[Union[str, Language]] = None, |
|
|
focus_areas: Optional[List[str]] = None |
|
|
) -> str: |
|
|
""" |
|
|
Review code for quality, bugs, and improvements. |
|
|
|
|
|
Args: |
|
|
code: Code to review |
|
|
language: Programming language |
|
|
focus_areas: Specific areas to focus on (e.g., security, performance) |
|
|
|
|
|
Returns: |
|
|
Code review feedback |
|
|
""" |
|
|
if isinstance(language, Language): |
|
|
language = language.value |
|
|
|
|
|
focus = f" Focus on: {', '.join(focus_areas)}." if focus_areas else "" |
|
|
|
|
|
prompt = f"""Review the following {language or ''} code for quality, potential bugs, |
|
|
and improvements.{focus} |
|
|
|
|
|
``` |
|
|
{code} |
|
|
```""" |
|
|
|
|
|
config = GenerationConfig(temperature=0.5, max_tokens=3000) |
|
|
response = self.generate(prompt, language, config) |
|
|
return response.code |
|
|
|
|
|
def debug( |
|
|
self, |
|
|
code: str, |
|
|
error_message: str, |
|
|
language: Optional[Union[str, Language]] = None |
|
|
) -> CodeResponse: |
|
|
""" |
|
|
Debug code with error message. |
|
|
|
|
|
Args: |
|
|
code: Code with the error |
|
|
error_message: Error message or description |
|
|
language: Programming language |
|
|
|
|
|
Returns: |
|
|
CodeResponse with fixed code |
|
|
""" |
|
|
if isinstance(language, Language): |
|
|
language = language.value |
|
|
|
|
|
prompt = f"""Debug the following {language or ''} code that produces this error: |
|
|
Error: {error_message} |
|
|
|
|
|
Code: |
|
|
``` |
|
|
{code} |
|
|
``` |
|
|
|
|
|
Provide the corrected code.""" |
|
|
|
|
|
config = GenerationConfig(temperature=0.3) |
|
|
return self.generate(prompt, language, config) |
|
|
|
|
|
def translate( |
|
|
self, |
|
|
code: str, |
|
|
source_language: Union[str, Language], |
|
|
target_language: Union[str, Language], |
|
|
config: Optional[GenerationConfig] = None |
|
|
) -> CodeResponse: |
|
|
""" |
|
|
Translate code from one language to another. |
|
|
|
|
|
Args: |
|
|
code: Source code |
|
|
source_language: Source programming language |
|
|
target_language: Target programming language |
|
|
config: Generation configuration |
|
|
|
|
|
Returns: |
|
|
CodeResponse with translated code |
|
|
""" |
|
|
if isinstance(source_language, Language): |
|
|
source_language = source_language.value |
|
|
if isinstance(target_language, Language): |
|
|
target_language = target_language.value |
|
|
|
|
|
prompt = f"""Translate the following {source_language} code to {target_language}: |
|
|
|
|
|
``` |
|
|
{code} |
|
|
```""" |
|
|
|
|
|
return self.generate(prompt, target_language, config) |
|
|
|
|
|
def generate_tests( |
|
|
self, |
|
|
code: str, |
|
|
language: Optional[Union[str, Language]] = None, |
|
|
test_framework: Optional[str] = None |
|
|
) -> CodeResponse: |
|
|
""" |
|
|
Generate unit tests for given code. |
|
|
|
|
|
Args: |
|
|
code: Code to generate tests for |
|
|
language: Programming language |
|
|
test_framework: Testing framework to use (e.g., pytest, jest) |
|
|
|
|
|
Returns: |
|
|
CodeResponse with test code |
|
|
""" |
|
|
if isinstance(language, Language): |
|
|
language = language.value |
|
|
|
|
|
framework_text = f" using {test_framework}" if test_framework else "" |
|
|
|
|
|
prompt = f"""Generate comprehensive unit tests{framework_text} for the following {language or ''} code: |
|
|
|
|
|
``` |
|
|
{code} |
|
|
```""" |
|
|
|
|
|
config = GenerationConfig(temperature=0.5, max_tokens=3000) |
|
|
return self.generate(prompt, language, config) |
|
|
|
|
|
def document( |
|
|
self, |
|
|
code: str, |
|
|
language: Optional[Union[str, Language]] = None, |
|
|
style: str = "google" |
|
|
) -> CodeResponse: |
|
|
""" |
|
|
Generate documentation for code. |
|
|
|
|
|
Args: |
|
|
code: Code to document |
|
|
language: Programming language |
|
|
style: Documentation style (google, numpy, sphinx) |
|
|
|
|
|
Returns: |
|
|
CodeResponse with documented code |
|
|
""" |
|
|
if isinstance(language, Language): |
|
|
language = language.value |
|
|
|
|
|
prompt = f"""Add comprehensive {style}-style documentation to the following {language or ''} code: |
|
|
|
|
|
``` |
|
|
{code} |
|
|
```""" |
|
|
|
|
|
config = GenerationConfig(temperature=0.3) |
|
|
return self.generate(prompt, language, config) |
|
|
|
|
|
def _make_request(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]: |
|
|
""" |
|
|
Make a request to the API. |
|
|
|
|
|
Args: |
|
|
endpoint: API endpoint |
|
|
payload: Request payload |
|
|
|
|
|
Returns: |
|
|
API response as dictionary |
|
|
|
|
|
Raises: |
|
|
requests.exceptions.RequestException: On API errors |
|
|
""" |
|
|
url = f"{self.base_url}{endpoint}" |
|
|
|
|
|
try: |
|
|
response = self.session.post( |
|
|
url, |
|
|
json=payload, |
|
|
timeout=self.timeout |
|
|
) |
|
|
response.raise_for_status() |
|
|
return response.json() |
|
|
except requests.exceptions.HTTPError as e: |
|
|
error_detail = e.response.text |
|
|
raise requests.exceptions.RequestException( |
|
|
f"API request failed: {e}. Details: {error_detail}" |
|
|
) |
|
|
|
|
|
def close(self): |
|
|
"""Close the session.""" |
|
|
self.session.close() |
|
|
|
|
|
def __enter__(self): |
|
|
"""Context manager entry.""" |
|
|
return self |
|
|
|
|
|
def __exit__(self, exc_type, exc_val, exc_tb): |
|
|
"""Context manager exit.""" |
|
|
self.close() |
|
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
|
|
|
client = TrovikuClient(api_key="your_api_key_here") |
|
|
|
|
|
|
|
|
response = client.generate( |
|
|
prompt="Create a function to calculate factorial recursively", |
|
|
language=Language.PYTHON |
|
|
) |
|
|
print("Generated Code:") |
|
|
print(response.code) |
|
|
print(f"\nTokens used: {response.tokens_used}") |
|
|
|
|
|
|
|
|
partial_code = """def fibonacci(n): |
|
|
if n <= 1: |
|
|
return n |
|
|
# Complete this function""" |
|
|
|
|
|
completion = client.complete(partial_code, Language.PYTHON) |
|
|
print("\nCompleted Code:") |
|
|
print(completion.code) |
|
|
|
|
|
|
|
|
explanation = client.explain( |
|
|
code="lambda x: x**2 + 2*x + 1", |
|
|
language=Language.PYTHON |
|
|
) |
|
|
print("\nExplanation:") |
|
|
print(explanation) |
|
|
|
|
|
client.close() |
