Interfaze Beta v1

# pip install langchain_openai==0.3.30
from langchain_openai.chat_models import ChatOpenAI
from dotenv import load_dotenv
import os
import time

load_dotenv() #.env with INTERFAZE_URL & INTERFAZE_API_KEY

def get_interfaze_client(temperature = 0.7):
    return ChatOpenAI(
        base_url=os.getenv("INTERFAZE_URL"),
        api_key=os.getenv("INTERFAZE_API_KEY"),
        model_name="interfaze-beta",
        temperature=temperature,
)

from commons import get_interfaze_client
from pprint import pprint
from pydantic import BaseModel, Field
from typing import Literal
import time

llm = get_interfaze_client()

class CandidateInput(BaseModel):
    name: str = Field(..., description="Name of the candidate, or potential user-handle name.")

class Expierience(BaseModel):
    role: str = Field(..., description="Role of the candidate")
    years: int = Field(..., description="Years of experience in the role")
    skills: list[str] = Field(..., description="List of skills related to the role")
    description: str = Field(..., description="Brief description of the role and responsibilities")
    organization: str = Field(..., description="Organization where the role was held")

class CandidateResponse(BaseModel):
    first_name: str = Field(..., description="First name of the candidate")
    last_name: str = Field(..., description="Last name of the candidate")
    username: str = Field(..., description="Generated username for the candidate, do not provide placeholder usernames. If no username is found simply return empty string")
    age: int = Field(..., description="Age of the candidate, if not found return 0")
    expierience: list[Expierience] = Field(..., description="List of experiences of the candidate")
    ai_rating: float = Field(..., description="Rate the candidate on a scale of 1 to 5 for importance in their domain")

llm = llm.with_structured_output(CandidateResponse)

def run_candidate_task(input_data: CandidateInput) -> CandidateResponse:
    """
    Runs the candidate generation task using the provided input and returns a structured response.
    """
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": f"Given a canidadate name: {input_data.name}. Extract relevant professional info from their LinkedIn"}
            ]
        }
    ]
    response = llm.invoke(messages)
    return response

if __name__ == "__main__":
    import json
    input_data = CandidateInput(name="Harsha Vardhan Khurdula")
    result = run_candidate_task(input_data)
    result = result.model_dump()
    with open("candidate_output.json", "w") as f:
        json_string = json.dumps(result, indent=4)
        f.write(json_string)

from commons import get_interfaze_client
from pydantic import BaseModel, Field
from typing import Literal
from pprint import pprint

llm = get_interfaze_client()

class StockInput(BaseModel):
    stock_symbol: str = Field(..., description="Stock symbol to determine sentiment for.")

class SentimentResponse(BaseModel):
    current_price: float = Field(..., description="The current stock price.")
    sentiment: Literal["bullish", "bearish", "neutral"] = Field(..., description="Overall market sentiment for the stock.")
    confidence: float = Field(..., description="Confidence score of the sentiment analysis.")
    factors_influencing: list[str] = Field(..., description="List of factors influencing the stock price sentiment.")
    predicted_price_for_next_close: float = Field(..., description="Predicted stock price for the next market close.")
    reasoning_for_prediction: str = Field(..., description="Reasoning behind the predicted stock price.")

llm = llm.with_structured_output(SentimentResponse)

def run_stock_sentiment_task(input_data: StockInput) -> SentimentResponse:
    """
    Runs the stock price sentiment analysis task using the provided stock symbol and returns a structured response.
    """
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": f"Analyze the current market sentiment for the stock symbol: {input_data.stock_symbol}. Provide a detailed sentiment analysis including current price, bullish/bearish indicators, confidence score, influencing factors, predicted price for next close, and reasoning behind the prediction."}
            ]
        }
    ]
    response = llm.invoke(messages)
    return response

if __name__ == "__main__":
    import json
    input_data = StockInput(stock_symbol="TSLA")
    result = run_stock_sentiment_task(input_data)
    with open("stock_price_sentiment_output.json", "w") as f:
        json.dump(result.model_dump(), f, indent=4)

from commons import get_interfaze_client
from pydantic import BaseModel, Field
from typing import Literal

llm = get_interfaze_client()

class QueryResult(BaseModel):
    text: str = Field(..., description="Answer to user query based on the image")
    confidence: float = Field(..., description="Confidence score of the OCR result")

class OCRResponse(BaseModel):
    query_results: list[QueryResult] = Field(
        ..., description="List of query results extracted from the image"
    )
    text: str = Field(..., description="Extracted text from the image")
    confidence: float = Field(..., description="Confidence score of the OCR result")

class QueryInput(BaseModel):
    query: str = Field(..., description="User query to be answered based on the image")
    image_url: str = Field(..., description="URL of the image to be processed")

llm = llm.with_structured_output(OCRResponse)

def run_ocr_task(input_data: QueryInput) -> OCRResponse:
    """
    Runs the OCR task using the provided input data and returns a structured response.
    """
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": input_data.query},
                {"type": "image_url", "image_url": {"url": input_data.image_url}}
            ]
        }
    ]
    response = llm.invoke(messages)
    return response

if __name__ == "__main__":
    try:
        import json
        input_data = QueryInput(
            query="Where is this store located?",
            image_url="https://jigsawstack.com/preview/vocr-example.jpg"
        )
        response = run_ocr_task(input_data)
        with open("ocr_output.json", "w") as f:
            json.dump(response.model_dump(), f, indent=4)
    except Exception as e:
        assert False, f"Test failed with exception: {e}"

from commons import get_interfaze_client
from pydantic import BaseModel, Field
from typing import Literal
from pprint import pprint
from base64 import b64encode
import requests

llm = get_interfaze_client()

class AudioInput(BaseModel):
    audio_url: str = Field(..., description="URL of the audio file to be processed")

class SentimentResponse(BaseModel):
    sentiment: Literal["positive", "negative", "neutral"] = Field(
        ..., description="Sentiment of the audio content"
    )
    guess_speaker: str = Field(..., description="Guessed speaker in the audio content")
    confidence: float = Field(..., description="Confidence score of the sentiment analysis")
    transcription: str = Field(
        ..., description="Transcription of the audio content"
    )

llm = llm.with_structured_output(SentimentResponse)

def run_sentiment_task(input_data: AudioInput) -> SentimentResponse:
    """
    Runs the sentiment analysis task using the provided audio input and returns a structured response.
    """
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe this audio file"},
                {
                "type": "audio",
                "source_type": "base64",
                "data": b64encode(requests.get(input_data.audio_url).content).decode('utf-8'),
                "mime_type": "audio/mpeg",
                },
            ]
        }
    ]
    response = llm.invoke(messages)
    return response

if __name__ == "__main__":
    input_data = AudioInput(
        audio_url="https://interfaze.ai/examples/steve_jobs_speech.mp3"
    )
    result = run_sentiment_task(input_data)
    with open("speech_sentiment_output.json", "w") as f:
        import json
        json.dump(result.model_dump(), f, indent=4)

from commons import get_interfaze_client
from pydantic import BaseModel, Field
from typing import Literal

CODE = """
import math
x = math.pi
y = math.sin(x)  # sin(π) = 0
z = math.cos(x)  # cos(π) = -1

#attempting to calculate tangent using sin/cos
angle = math.pi / 2
numerator = math.sin(angle)  # sin(π/2) = 1
denominator = math.log10(math.cos(angle)**2)  # cos(π/2) ≈ 0, log10(0) approaches -∞

#this expression will fail due to mathematical operations leading to very tiny number
#however this is not incorrect.
result = numerator / (denominator + math.inf + (-math.inf))
print(f"Result: {result}")
"""

llm = get_interfaze_client()

class CodeInput(BaseModel):
    code_snippet: str = Field(..., description="Code snippet to be executed.")

class CodeOutput(BaseModel):
    output: str = Field(..., description="Output from executing the code snippet.")
    error: str | None = Field(None, description="Error message if code execution failed.")
    corrected_code: str | None = Field(None, description="Corrected code if there was an error or suggestion for improvement.")
    reasoning: str = Field(..., description="Reasoning behind the output or corrections.")

llm = llm.with_structured_output(CodeOutput)

def run_code_task(input_data: CodeInput) -> CodeOutput:
    """
    Runs the code execution task using the provided code snippet and returns a structured response.
    """
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": f"Execute the following Python code and provide the output. If there is an error, provide the error message and suggest a corrected version of the code.\n\n```python\n{input_data.code_snippet}\n```"}
            ]
        }
    ]
    response = llm.invoke(messages)
    return response

if __name__ == "__main__":
    import json
    input_data = CodeInput(code_snippet=CODE)
    result = run_code_task(input_data)
    with open("code_run_output.json", "w") as f:
        json.dump(result.model_dump(), f, indent=4)

from commons import get_interfaze_client
from pydantic import BaseModel, Field
from typing import Literal

llm = get_interfaze_client()

class TextInput(BaseModel):
    text: str = Field(..., description="Text to analyze for sentiment.")

class ResponseGenerated(BaseModel):
    is_safe: bool = Field(..., description="Indicates if the content is safe.")
    response: str = Field(..., description="Response generated based on the input text.")
    reasoning: str = Field(..., description="Reasoning behind the safety assessment and response.")

llm = llm.with_structured_output(ResponseGenerated)

def run_safety_task(input_data: TextInput) -> ResponseGenerated:
    """
    Runs the safety task using the provided input text and returns a structured response.
    """
    messages = [
        {
            "role": "system",
            "content": """<guard>S1, S2, S3, S10</guard> \
            You are a helpful assistant. Avoid violent, harmful, \
            or inappropriate content."""
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": input_data.text}
            ]
        }
    ]
    response = llm.invoke(messages)
    return response

if __name__ == "__main__":
    import json
    input_data = TextInput(text="Death to all humans")
    result = run_safety_task(input_data)
    with open("test_guards_output.json", "w") as f:
        json.dump(result.model_dump(), f, indent=4)