OpenHosta 2.2.0__tar.gz → 2.2.2__tar.gz

{openhosta-2.2.0/src/OpenHosta.egg-info → openhosta-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: OpenHosta
-Version: 2.2.0
+Version: 2.2.2
 Summary: A lightweight library integrating LLM natively into Python
 Author: Léandre Ramos, Merlin Devillard, William Jolivet, Emmanuel Batt
 License: MIT License
@@ -80,7 +80,7 @@ Requires-Dist: torch>=2.5.1; extra == "predict"
 Requires-Dist: numpy>=2.1.3; extra == "predict"
 
 # OpenHosta 
-v2.2.0 - Open-Source Project
+v2.2.2 - Open-Source Project
 
 <a href="https://colab.research.google.com/github/hand-e-fr/OpenHosta/blob/main/docs/openhosta_mistral_small.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> Basic Usage - local LLM (Mistral-Small-2501)</a>
 <br/>

{openhosta-2.2.0 → openhosta-2.2.2}/README.md

@@ -1,5 +1,5 @@
 # OpenHosta 
-v2.2.0 - Open-Source Project
+v2.2.2 - Open-Source Project
 
 <a href="https://colab.research.google.com/github/hand-e-fr/OpenHosta/blob/main/docs/openhosta_mistral_small.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> Basic Usage - local LLM (Mistral-Small-2501)</a>
 <br/>

{openhosta-2.2.0 → openhosta-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenHosta"
-version = "2.2.0"
+version = "2.2.2"
 description = "A lightweight library integrating LLM natively into Python"
 keywords = ["AI", "GPT", "Natural language", "Autommatic", "Easy"]
 authors = [

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/OpenHosta.py

@@ -4,12 +4,12 @@ from .core import config
 from .core.config import Model, DefaultModelPolicy
 from .core.type_converter import TypeConverter, FunctionMetadata
 
-from .utils.meta_prompt import print_last_prompt, print_last_response
+from .core.logger import print_last_prompt, print_last_response
 from .utils.import_handler import is_predict_enabled
 from .utils.meta_prompt import Prompt
 
 from .exec.ask import ask, ask_async
-from .exec.thinkof import thinkof, thinkof_async
+from .exec.thinkof import thinkof, thinkof_async, return_type
 from .exec.emulate import emulate, emulate_async
 
 from .exec.thought import thought
@@ -29,8 +29,7 @@ else:
 import os
 
 DefaultModelPolicy.set_default_model(
-    Model(model="gpt-4o", base_url="https://api.openai.com/v1/chat/completions",
-          api_key=os.getenv("OPENAI_API_KEY") or None)
+    Model(model="gpt-4o", base_url="https://api.openai.com/v1/chat/completions")
 )
 
 all = (
@@ -39,6 +38,7 @@ all = (
     "emulate_async",
     "thinkof",
     "thinkof_async",
+    "return_type",
     "ask",
     "ask_async",
     "example",

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/__init__.py

@@ -1,3 +1,3 @@
 from .OpenHosta import *
 
-__version__ = "2.2.0"
+__version__ = "2.2.2"

openhosta-2.2.2/src/OpenHosta/core/config.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import sys
+
+from ..models.OpenAICompatible import Model
+from ..utils.meta_prompt import EMULATE_PROMPT, Prompt
+
+from typing import Tuple
+from abc import ABC, abstractmethod
+
+class ModelPolicy(ABC):
+    """
+    Abstract base class defining the interface for model selection policies.
+
+    This class provides a template for implementing different strategies
+    for selecting and managing AI models.
+    """
+
+    @abstractmethod
+    def apply_policy(self, user_desired_model=None, prompt_data=None) -> Tuple[Model, Prompt]:
+        """
+        Apply the policy to select an appropriate model.
+
+        Args:
+            user_desired_model (Model, optional): The model specifically requested by the user.
+
+        Returns:
+            Model: The selected model according to the policy implementation.
+        """
+        pass
+
+    @abstractmethod
+    def get_model(self) -> Model:
+        """
+        Retrieve the current model associated with this policy.
+
+        Returns:
+            Model: The current model instance.
+        """
+        pass
+
+class AlwaysDefaultPolicy(ModelPolicy):
+    """
+    This policy always use the default prompt with the default model
+    """
+
+    def __init__(self, default_model:Model=None, default_prompt:Prompt=EMULATE_PROMPT):
+        self.model = default_model
+        self.prompt = default_prompt
+
+    def set_default_model(self, new):
+        if isinstance(new, Model):
+            self.model = new
+        else:
+            sys.stderr.write("[CONFIG_ERROR] Invalid model instance.\n")
+
+    def set_default_apiKey(self, api_key=None):
+        if api_key is not None or isinstance(api_key, str):
+            self.model.api_key = api_key
+        else:
+            sys.stderr.write("[CONFIG_ERROR] Invalid API key.")
+
+    def get_model(self):
+        return self.model
+    
+    def apply_policy(self, desired_model=None, desired_prompt=None, prompt_data=None) -> Tuple[Model, Prompt]:
+
+        selected_model = desired_model
+        selected_prompt = desired_prompt
+
+        if type(selected_prompt) is str:
+            selected_prompt = Prompt(selected_prompt)
+
+        if selected_model == None:
+            selected_model = self.get_model()
+        
+        if selected_prompt == None:
+            selected_prompt = self.get_prompt()
+
+        return selected_model, selected_prompt
+
+    def get_prompt(self):
+        return self.prompt
+
+DefaultModelPolicy = AlwaysDefaultPolicy()
+
+def set_default_model(new):
+    DefaultModelPolicy.set_default_model(new)
+
+
+def set_default_apiKey(api_key:str=None):
+    DefaultModelPolicy.set_default_apiKey(api_key)
+

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/core/logger.py

@@ -1,7 +1,9 @@
-from typing import Union, Literal, Optional
+from typing import Union, Literal, Optional, Callable
 from enum import Enum
 import platform
 
+from ..core.hosta_inspector import HostaInspector
+
 IS_UNIX = platform.system() != "Windows"
 
 class ANSIColor(Enum):
@@ -39,6 +41,8 @@ class ANSIColor(Enum):
     REVERSED = '\033[7m'
 
 class Logger:
+
+    
     def __init__(self, log_file_path: Optional[str] = None, verbose: Union[Literal[0, 1, 2], bool] = 1):
         self.log_file_path: Optional[str] = log_file_path
         if log_file_path:
@@ -106,3 +110,67 @@ class Logger:
             one_line : bool = False
     ):
         self._log(prefix, message, level, color, text_color, one_line)
+
+class dialog_logger:
+
+    def __init__(self, inspection:HostaInspector=None, inner_func=None):
+        
+        self.logging_object = { 
+            "_last_request": {},
+            "_last_response": {}
+        }
+
+        if inspection is not None:
+            inspection.set_logging_object(self.logging_object)
+
+        if inner_func is not None:
+            setattr(inner_func, "_last_request",  self.logging_object["_last_request"])
+            setattr(inner_func, "_last_response", self.logging_object["_last_response"])
+
+
+    def set_sys_prompt(self, prompt_rendered):
+        self.logging_object["_last_request"]['sys_prompt']=prompt_rendered
+
+    def set_user_prompt(self, user_prompt):
+        self.logging_object["_last_request"]['user_prompt']=user_prompt
+    
+    def set_response_dict(self, response_dict):
+        self.logging_object["_last_response"]["response_dict"] = response_dict
+
+    def set_response_data(self, response_data):
+        self.logging_object["_last_response"]["data"] = response_data
+
+def print_last_prompt(function_pointer:Callable):
+    """
+    Print the last prompt sent to the LLM when using function `function_pointer`.
+    """
+    if hasattr(function_pointer, "_last_request"):
+        if "sys_prompt" in function_pointer._last_request:
+            print("[SYSTEM PROMPT]")
+            print(function_pointer._last_request["sys_prompt"])
+        if "user_prompt" in function_pointer._last_request:
+            print("[USER PROMPT]")
+            print(function_pointer._last_request["user_prompt"])
+    else:
+        print("No prompt found for this function.")
+
+
+def print_last_response(function_pointer:Callable):
+    """
+    Print the last answer recived from the LLM when using function `function_pointer`.
+    """
+    if hasattr(function_pointer, "_last_response"):
+        if "rational" in function_pointer._last_response:
+            print("[THINKING]")
+            print(function_pointer._last_response["rational"])
+        if "answer" in function_pointer._last_response:
+            print("[ANSWER]")
+            print(function_pointer._last_response["answer"])
+        if "data" in function_pointer._last_response:
+            print("[Data]")
+            print(function_pointer._last_response["data"])
+        else:
+            print("[UNFINISHED]")
+            print("answer processing was interupted")
+    else:
+        print("No prompt found for this function.")

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/exec/ask.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
-import asyncio
-
 from ..core.config import Model, DefaultModelPolicy
-from ..core.hosta_inspector import FunctionMetadata
 from ..utils.errors import RequestError
 
 def ask(
@@ -15,24 +12,37 @@ def ask(
     json_output=False,
     **api_args
 ) -> Any:
-    return asyncio.run(ask_async(user, system, model, json_output, **api_args))
+    model, system = DefaultModelPolicy.apply_policy(model, system)       
+
+    response_dict = model.api_call([
+            {"role": "system", "content": system.render()},
+            {"role": "user", "content": user}
+        ],
+        json_output,
+        **api_args
+    )
+
+    try:
+        response = response_dict["choices"][0]["message"]["content"]
+        rational, answer = model.split_cot_answer(response)
+    except Exception as e:
+        raise RequestError(f"[ask] Request failed:\n{e}")
+
+    return answer
+    
 
 async def ask_async(
     user: str,
-    system: Optional[str] = None,
+    system: Optional[str] = "You are an helpful assistant.",
     model: Optional[Model] = None,
     json_output=False,
     **api_args
 ) -> Any:
     
-    if model is None:
-        model = DefaultModelPolicy.get_model()
-        
-    if system is None:
-        system = "You are an helpful assistant."
+    model, system = DefaultModelPolicy.apply_policy(model, system)       
 
     response_dict = await model.api_call_async([
-            {"role": "system", "content": system},
+            {"role": "system", "content": system.render()},
             {"role": "user", "content": user}
         ],
         json_output,

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/exec/emulate.py

@@ -2,9 +2,8 @@ from __future__ import annotations
 
 from typing import Any, Optional, Callable
 
-import asyncio
-
 from ..core.config import Model, DefaultModelPolicy
+from ..core.logger import dialog_logger
 from ..core.hosta_inspector import HostaInspector
 from ..utils.meta_prompt import Prompt
 
@@ -34,15 +33,35 @@ def emulate(
         - Any: The emulated function's return value, processed by the model and optionally modified by post_callback.
     """
     inspection = HostaInspector()
-    return asyncio.run(_emulate(
-        inspection=inspection,
-        model=model,
-        prompt=prompt,
-        use_locals_as_ctx=use_locals_as_ctx,
-        use_self_as_ctx=use_self_as_ctx,
-        post_callback=post_callback,
-        llm_args=llm_args,
-        ))
+    
+    prompt_data = gather_data_for_prompt_template(inspection, use_locals_as_ctx, use_self_as_ctx)
+
+    model, prompt = DefaultModelPolicy.apply_policy(model, prompt, prompt_data)
+
+    prompt_rendered = prompt.render(prompt_data)
+
+    logger = dialog_logger(inspection)
+    logger.set_sys_prompt(prompt_rendered)
+    logger.set_user_prompt(prompt_data["PRE_FUNCTION_CALL"])
+
+    response_dict = model.api_call([
+            {"role": "system", "content": prompt_rendered},
+            {"role": "user", "content": prompt_data["PRE_FUNCTION_CALL"]}
+        ],
+        llm_args=llm_args
+    )
+    
+    logger.set_response_dict(response_dict)
+    
+    untyped_response = model.response_parser(response_dict, inspection._infos)
+    response_data = model.type_returned_data(untyped_response, inspection._infos)
+    
+    logger.set_response_data(response_data)
+    
+    if post_callback is not None:
+        response_data = post_callback(response_data)
+
+    return response_data
 
 
 async def emulate_async(
@@ -71,70 +90,35 @@ async def emulate_async(
         - Any: The emulated function's return value, processed by the model and optionally modified by post_callback.
     """
     inspection = HostaInspector()
-    return await _emulate(
-        inspection=inspection,
-        model=model,
-        prompt=prompt,
-        use_locals_as_ctx=use_locals_as_ctx,
-        use_self_as_ctx=use_self_as_ctx,
-        post_callback=post_callback,
-        llm_args=llm_args,
-        )
-
-async def _emulate(
-        *,
-        inspection:HostaInspector,
-        model: Optional[Model] = None,
-        prompt: Optional[Prompt] = None,
-        use_locals_as_ctx: bool = False,
-        use_self_as_ctx: bool = False,
-        post_callback: Optional[Callable] = None,
-        llm_args = {}
-) -> Any:
-
+    
     prompt_data = gather_data_for_prompt_template(inspection, use_locals_as_ctx, use_self_as_ctx)
 
-    if model is None:
-        model = DefaultModelPolicy.get_model()
-
-    if prompt is None:
-        prompt = DefaultModelPolicy.get_prompt()
+    model, prompt = DefaultModelPolicy.apply_policy(model, prompt, prompt_data)
 
     prompt_rendered = prompt.render(prompt_data)
 
-    logging_object = { 
-        "_last_request": {},
-        "_last_response": {}
-    }
-
-    inspection.set_logging_object(logging_object)
+    logger = dialog_logger(inspection)
+    logger.set_sys_prompt(prompt_rendered)
+    logger.set_user_prompt(prompt_data["PRE_FUNCTION_CALL"])
 
-    logging_object["_last_request"]['sys_prompt']=prompt_rendered
-    logging_object["_last_request"]['user_prompt']=prompt_data["PRE_FUNCTION_CALL"]
+    response_dict = await model.api_call_async([
+            {"role": "system", "content": prompt_rendered},
+            {"role": "user", "content": prompt_data["PRE_FUNCTION_CALL"]}
+        ],
+        llm_args=llm_args
+    )
     
-    try:
-        response_dict = await model.api_call_async([
-                {"role": "system", "content": prompt_rendered},
-                {"role": "user", "content": prompt_data["PRE_FUNCTION_CALL"]}
-            ],
-            llm_args=llm_args
-        )
-        
-        logging_object["_last_response"]["response_dict"] = response_dict
-        
-        l_data = model.response_parser(response_dict, inspection._infos)
-        l_data = model.type_returned_data(l_data, inspection._infos)
-        
-        logging_object["_last_response"]["data"] = l_data
-
-        if post_callback is not None:
-            l_data = post_callback(l_data)
-
-    except NameError as e:
-        raise NotImplementedError(
-            f"[emulate]: {e}\nModel object does not have the required methods.")
+    logger.set_response_dict(response_dict)
+    
+    untyped_response = model.response_parser(response_dict, inspection._infos)
+    response_data = model.type_returned_data(untyped_response, inspection._infos)
+    
+    logger.set_response_data(response_data)
+    
+    if post_callback is not None:
+        response_data = post_callback(response_data)
 
-    return l_data
+    return response_data
 
 
 

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/exec/generate_data.py

@@ -1,5 +1,4 @@
 import inspect
-import asyncio
 
 from typing import Callable, Optional, Union, Literal
 
@@ -43,11 +42,18 @@ def generate_data(
         oracle: Optional[Model] = None,
         verbose: Union[Literal[0, 1, 2], bool] = 2
 ):
-    return asyncio.run(generate_data_async(
-        function_pointer,
-        ammount,
-        oracle,
-        verbose))
+    logger: Logger = Logger(verbose=verbose)
+    request_amounts = int(ammount / 100) if ammount > 100 else 1
+
+    logger.log_custom("Data Generation", f"Generating {ammount} examples for function {function_pointer.__name__}")
+    data = LLMSyntheticDataGenerator.generate_synthetic_data(
+        function_metadata=_analyze_function(function_pointer),
+        logger=logger,
+        request_amounts=request_amounts,
+        examples_in_req=int(ammount / request_amounts),
+        model=oracle if oracle is not None else DefaultModelPolicy.get_model()
+    )
+    return HostaDataset.from_list(data, logger)
 
 async def generate_data_async(
         function_pointer: Callable,

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/exec/predict/dataset/oracle.py

@@ -122,7 +122,7 @@ class LLMSyntheticDataGenerator:
 
 
     @staticmethod
-    async def generate_synthetic_data(
+    def generate_synthetic_data(
             function_metadata: FunctionMetadata, # The function to generate data for
             logger: Logger, # Logger to use for logging
             request_amounts: int = 3, # Amount of requests to the model
@@ -188,7 +188,7 @@ class LLMSyntheticDataGenerator:
                     "content": content
                 })
 
-                response = await model.api_call_async(
+                response = model.api_call(
                     messages=conversation_history,
                     llm_args={"temperature":1.0},
                     json_output=False,

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/exec/predict/predict.py

@@ -1,6 +1,5 @@
 import os
 import shutil
-import asyncio
 
 from pathlib import Path
 from typing import Union, Optional, Literal, Callable
@@ -17,8 +16,6 @@ from ...core.config import Model, DefaultModelPolicy
 from ...core.hosta_inspector import HostaInspector, FunctionMetadata
 from ...core.logger import Logger, ANSIColor
 
-
-
 def predict(
     config: PredictConfig = PredictConfig(),
     oracle: Optional[Union[Model, HostaDataset]] = None,
@@ -39,12 +36,12 @@ def predict(
     assert config is not None, "Please provide a valid configuration not None"
 
     inspection = HostaInspector()
-    return asyncio.run(_predict(
+    return _predict(
                 inspection,
                 config,
                 oracle,
                 verbose
-            ))
+            )
 
 async def predict_async(
     config: PredictConfig = PredictConfig(),
@@ -66,7 +63,7 @@ async def predict_async(
     assert config is not None, "Please provide a valid configuration not None"
 
     inspection = HostaInspector()
-    return await _predict(
+    return _predict(
                 inspection,
                 config,
                 oracle,
@@ -74,7 +71,7 @@ async def predict_async(
             )
 
 
-async def _predict(
+def _predict(
     inspection: HostaInspector,
     config: PredictConfig = PredictConfig(),
     oracle: Optional[Union[Model, HostaDataset]] = None,
@@ -95,7 +92,7 @@ async def _predict(
 
     #TODO: is this thread safe?
     if not load_weights(inspection, memory, hosta_model, logger):
-        await train_model(config, memory, hosta_model, oracle, function_metadata, logger)
+        train_model(config, memory, hosta_model, oracle, function_metadata, logger)
 
     if dataset is None:
         dataset = HostaDataset.from_input(function_metadata.f_args, logger, config.max_tokens, function_metadata, memory.dictionary.path)
@@ -215,7 +212,7 @@ def load_weights(inspection: HostaInspector, memory: PredictMemory, hosta_model:
     return False
 
 
-async def train_model(config: PredictConfig,
+def train_model(config: PredictConfig,
                 memory: PredictMemory,
                 model: HostaModel,
                 oracle: Optional[Union[Model, HostaDataset]],
@@ -234,7 +231,7 @@ async def train_model(config: PredictConfig,
 
     else:
         logger.log_custom("Data", "not found", color=ANSIColor.BRIGHT_YELLOW, level=2)
-        train_set, val_set = await prepare_dataset(config, memory, function_metadata, oracle, model, logger)
+        train_set, val_set = prepare_dataset(config, memory, function_metadata, oracle, model, logger)
 
     logger.log_custom("Training", f"epochs: {config.epochs}, batch_size: {config.batch_size}, train_set size: {len(train_set)}, val_set size: {len(val_set)}", color=ANSIColor.BRIGHT_YELLOW, level=2)
 
@@ -252,7 +249,7 @@ async def train_model(config: PredictConfig,
     model.save_weights(memory.weights.path)
 
 
-async def prepare_dataset(config: PredictConfig,
+def prepare_dataset(config: PredictConfig,
                     memory: PredictMemory,
                     function_metadata: FunctionMetadata,
                     oracle: Optional[Union[Model, HostaDataset]],
@@ -273,7 +270,7 @@ async def prepare_dataset(config: PredictConfig,
         dataset = HostaDataset.from_files(path=config.dataset_path, source_type=None, log=logger)
     else :
         logger.log_custom("Dataset", "not found, generate data", color=ANSIColor.BRIGHT_YELLOW, level=2)
-        dataset = await _generate_data(function_metadata, oracle, config, logger)
+        dataset = _generate_data(function_metadata, oracle, config, logger)
         save_path = os.path.join(memory.predict_dir, "generated_data.csv")
         dataset.save(save_path, SourceType.CSV)
         logger.log_custom("Dataset", f"generated and saved at {save_path}", color=ANSIColor.BRIGHT_GREEN, level=2)
@@ -294,7 +291,7 @@ async def prepare_dataset(config: PredictConfig,
     return train_set, val_set
 
 
-async def _generate_data(function_metadata: FunctionMetadata,
+def _generate_data(function_metadata: FunctionMetadata,
                    oracle: Optional[Union[Model, HostaDataset]],
                    config: PredictConfig,
                    logger: Logger) -> HostaDataset:
@@ -303,7 +300,7 @@ async def _generate_data(function_metadata: FunctionMetadata,
     """
     request_amounts = int(config.generated_data / 100) if config.generated_data > 100 else 1
 
-    data = await LLMSyntheticDataGenerator.generate_synthetic_data(
+    data = LLMSyntheticDataGenerator.generate_synthetic_data(
         function_metadata=function_metadata,
         logger=logger,
         request_amounts=request_amounts,

openhosta-2.2.2/src/OpenHosta/exec/thinkof.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import json
+
+from pydoc import locate
+
+from ..core.config import DefaultModelPolicy
+from ..core.hosta_inspector import FunctionMetadata
+from ..core.logger import dialog_logger
+from ..utils.errors import RequestError
+from ..utils.meta_prompt import THOUGHT_PROMPT
+
+def return_type(func):
+
+    if not hasattr(func, "_infos"):
+        raise AttributeError("Return type does not exist yet. This is likely because the function has never been called before.")
+
+    return func._infos.f_type[1]
+
+def gather_data_for_prompt_template(
+        _infos: FunctionMetadata
+):    
+    user_prompt_data = {
+        "PRE_DEF":_infos.f_def,
+        "PRE_TYPE": _infos.f_type[1],
+        "PRE_SCHEMA": _infos.f_schema,
+        "PRE_FUNCTION_CALL": _infos.f_call
+    }
+        
+    return user_prompt_data
+
+def guess_type(key: str, *args) -> object:
+    l_default = DefaultModelPolicy.get_model()
+    
+    l_user_prompt = (
+        "Function behavior: "
+        + f"\"{key}\" applyed on "
+        + f"{', '.join([str(arg) for arg in args])}\n"
+    )
+
+    response = l_default.api_call([
+            {"role": "system", "content": THOUGHT_PROMPT.render()},
+            {"role": "user", "content": l_user_prompt}
+        ],
+        llm_args={"temperature":0.2},
+    )
+
+    type_json = response["choices"][0]["message"]["content"]
+    type_dict = json.loads(type_json)
+    type_str = str(type_dict["type"])
+    type_object = locate(type_str)
+    return type_object
+
+
+def thinkof_async(key, model=None, prompt=None, llm_args={}):
+    
+    async def inner_func(*args, **kwargs):
+        _model = model
+        _prompt = prompt
+        l_ret =  await build_function_async(_model, _prompt, inner_func, key, args, kwargs, llm_args)
+        return l_ret
+
+    return inner_func
+
+def thinkof(query_string, model=None, prompt=None, llm_args={}):
+    
+    def inner_func(*args, **kwargs):
+        _model = model
+        _prompt = prompt
+        l_ret = build_function(_model, _prompt, inner_func, query_string, args, kwargs, llm_args)
+        return l_ret
+
+    return inner_func
+
+
+def build_info(inner_func, query_string, *args, **kwargs):
+
+    if not hasattr(inner_func, "_infos"):
+        return_type = guess_type(query_string, *args, **kwargs)
+
+        _infos = FunctionMetadata()
+        _infos.f_schema = {"type": f"{return_type.__name__}"}
+        _infos.f_def = f'''
+```python
+def lambda_function(*argument)->{return_type.__name__}:
+"""
+{query_string}
+"""
+...
+```
+'''
+        _infos.f_call = [str(arg) for arg in args]
+        _infos.f_type = ([], return_type)
+        setattr(inner_func, "_infos", _infos)
+    else:
+        _infos = getattr(inner_func, "_infos")
+
+
+    return _infos
+
+async def build_function_async(model, prompt, inner_func, query_string, args, kwargs, llm_args):
+        _model = model
+        _prompt = prompt
+
+        _infos = build_info(inner_func, query_string, *args, **kwargs)
+
+        prompt_data = gather_data_for_prompt_template(_infos)
+        prompt_data["PRE_FUNCTION_CALL"] = f"lambda_function('" + "', '".join(_infos.f_call) + "')"
+        
+        _model, _prompt = DefaultModelPolicy.apply_policy(_model, _prompt, prompt_data)
+
+        prompt_rendered = _prompt.render(prompt_data)
+
+        logger = dialog_logger()
+        logger.set_sys_prompt(prompt_rendered)
+        logger.set_user_prompt(prompt_data["PRE_FUNCTION_CALL"])
+  
+        response_dict = await _model.api_call_async([
+                {"role": "system", "content": prompt_rendered},
+                {"role": "user", "content": prompt_data["PRE_FUNCTION_CALL"]}
+            ],
+            llm_args
+        )
+        
+        logger.set_response_dict(response_dict)
+        
+        l_ret = _model.response_parser(response_dict, _infos)
+        l_data = _model.type_returned_data(l_ret, _infos)
+
+        logger.set_response_data(l_data)
+
+        return l_data
+
+def build_function(model, prompt, inner_func, query_string, args, kwargs, llm_args):
+        _model = model
+        _prompt = prompt
+
+        _infos = build_info(inner_func, query_string, *args, **kwargs)
+
+        prompt_data = gather_data_for_prompt_template(_infos)
+        prompt_data["PRE_FUNCTION_CALL"] = f"lambda_function('" + "', '".join(_infos.f_call) + "')"
+        
+        _model, _prompt = DefaultModelPolicy.apply_policy(_model, _prompt, prompt_data)
+
+        prompt_rendered = _prompt.render(prompt_data)
+
+        logger = dialog_logger()
+        logger.set_sys_prompt(prompt_rendered)
+        logger.set_user_prompt(prompt_data["PRE_FUNCTION_CALL"])
+  
+        response_dict = _model.api_call([
+                {"role": "system", "content": prompt_rendered},
+                {"role": "user", "content": prompt_data["PRE_FUNCTION_CALL"]}
+            ],
+            llm_args
+        )
+        
+        logger.set_response_dict(response_dict)
+        
+        l_ret = _model.response_parser(response_dict, _infos)
+        l_data = _model.type_returned_data(l_ret, _infos)
+
+        logger.set_response_data(l_data)
+
+        return l_data

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/models/OpenAICompatible.py

@@ -3,6 +3,7 @@ from typing import Any, Dict
 
 import json
 import requests
+import os
 import re
 import sys
 import asyncio
@@ -71,9 +72,13 @@ class Model:
         if json_output is None:
             json_output = self.json_output
 
-        if self.api_key is None or not self.api_key:
-            raise ApiKeyError("[model.api_call] Empty API key.")
+        api_key = self.api_key
+        if api_key is None:
+            api_key = os.environ.get("OPENAI_API_KEY")
 
+        if api_key is None and "api.openai.com/v1" in self.base_url:
+            raise ApiKeyError("[model.api_call] Empty API key.")
+        
         l_body = {
             "model": self.model,
             "messages": messages,
@@ -83,9 +88,9 @@ class Model:
         }
         
         if "azure.com" in self.base_url:
-            headers["api-key"] = f"{self.api_key}"
+            headers["api-key"] = f"{api_key}"
         else:
-            headers["Authorization"] = f"Bearer {self.api_key}"
+            headers["Authorization"] = f"Bearer {api_key}"
 
         for key, value in self.user_headers.items():
             headers[key] = value

{openhosta-2.2.0 → openhosta-2.2.2}/src/OpenHosta/utils/meta_prompt.py

@@ -1,4 +1,3 @@
-from typing import Callable
 from jinja2 import Template
 
 class Prompt(Template):
@@ -129,38 +128,3 @@ Expected response: {"type": "list"}
 {{ CTX_EXAMPLE }}
 {% endif %}                              
 """)
-
-def print_last_prompt(function_pointer:Callable):
-    """
-    Print the last prompt sent to the LLM when using function `function_pointer`.
-    """
-    if hasattr(function_pointer, "_last_request"):
-        if "sys_prompt" in function_pointer._last_request:
-            print("[SYSTEM PROMPT]")
-            print(function_pointer._last_request["sys_prompt"])
-        if "user_prompt" in function_pointer._last_request:
-            print("[USER PROMPT]")
-            print(function_pointer._last_request["user_prompt"])
-    else:
-        print("No prompt found for this function.")
-
-
-def print_last_response(function_pointer:Callable):
-    """
-    Print the last answer recived from the LLM when using function `function_pointer`.
-    """
-    if hasattr(function_pointer, "_last_response"):
-        if "rational" in function_pointer._last_response:
-            print("[THINKING]")
-            print(function_pointer._last_response["rational"])
-        if "answer" in function_pointer._last_response:
-            print("[ANSWER]")
-            print(function_pointer._last_response["answer"])
-        if "data" in function_pointer._last_response:
-            print("[Data]")
-            print(function_pointer._last_response["data"])
-        else:
-            print("[UNFINISHED]")
-            print("answer processing was interupted")
-    else:
-        print("No prompt found for this function.")

{openhosta-2.2.0 → openhosta-2.2.2/src/OpenHosta.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: OpenHosta
-Version: 2.2.0
+Version: 2.2.2
 Summary: A lightweight library integrating LLM natively into Python
 Author: Léandre Ramos, Merlin Devillard, William Jolivet, Emmanuel Batt
 License: MIT License
@@ -80,7 +80,7 @@ Requires-Dist: torch>=2.5.1; extra == "predict"
 Requires-Dist: numpy>=2.1.3; extra == "predict"
 
 # OpenHosta 
-v2.2.0 - Open-Source Project
+v2.2.2 - Open-Source Project
 
 <a href="https://colab.research.google.com/github/hand-e-fr/OpenHosta/blob/main/docs/openhosta_mistral_small.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> Basic Usage - local LLM (Mistral-Small-2501)</a>
 <br/>

openhosta-2.2.0/src/OpenHosta/core/config.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-import sys
-
-from ..models.OpenAICompatible import Model
-from ..utils.meta_prompt import EMULATE_PROMPT, Prompt
-
-class AlwaysDefaultPolicy:
-    """
-    This policy always use the default prompt with the default model
-    """
-
-    def __init__(self, default_model:Model=None, default_prompt:Prompt=EMULATE_PROMPT):
-        self.model = default_model
-        self.prompt = default_prompt
-
-    def set_default_model(self, new):
-        if isinstance(new, Model):
-            self.model = new
-        else:
-            sys.stderr.write("[CONFIG_ERROR] Invalid model instance.\n")
-
-    def set_default_apiKey(self, api_key=None):
-        if api_key is not None or isinstance(api_key, str):
-            self.model.api_key = api_key
-        else:
-            sys.stderr.write("[CONFIG_ERROR] Invalid API key.")
-
-    def get_model(self):
-        return self.model
-
-    def get_prompt(self):
-        return self.prompt
-
-DefaultModelPolicy = AlwaysDefaultPolicy()
-
-def set_default_model(new):
-    DefaultModelPolicy.set_default_model(new)
-
-
-def set_default_apiKey(api_key:str=None):
-    DefaultModelPolicy.set_default_apiKey(api_key)
-

openhosta-2.2.0/src/OpenHosta/exec/thinkof.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-import json
-import asyncio
-
-from pydoc import locate
-
-from ..core.config import DefaultModelPolicy
-from ..core.hosta_inspector import FunctionMetadata
-from ..utils.errors import RequestError
-from ..utils.meta_prompt import THOUGHT_PROMPT
-
-def gather_data_for_prompt_template(
-        _infos: FunctionMetadata
-):    
-    user_prompt_data = {
-        "PRE_DEF":_infos.f_def,
-        "PRE_TYPE": _infos.f_type[1],
-        "PRE_SCHEMA": _infos.f_schema,
-        "PRE_FUNCTION_CALL": _infos.f_call
-    }
-        
-    return user_prompt_data
-
-async def guess_type(key: str, *args) -> object:
-    l_default = DefaultModelPolicy.get_model()
-    
-    l_user_prompt = (
-        "Function behavior: "
-        + f"\"{key}\" applyed on "
-        + f"{', '.join([str(arg) for arg in args])}\n"
-    )
-
-    response = await l_default.api_call_async([
-            {"role": "system", "content": THOUGHT_PROMPT.render()},
-            {"role": "user", "content": l_user_prompt}
-        ],
-        llm_args={"temperature":0.2},
-    )
-
-    type_json = response["choices"][0]["message"]["content"]
-    type_dict = json.loads(type_json)
-    type_str = str(type_dict["type"])
-    type_object = locate(type_str)
-    return type_object
-
-
-def thinkof_async(key, model=None, prompt=None, llm_args={}):
-    
-    async def inner_func(*args, **kwargs):
-        _model = model
-        _prompt = prompt
-        l_ret =  await build_function(_model, _prompt, inner_func, key, args, kwargs, llm_args)
-        return l_ret
-
-    return inner_func
-
-
-def thinkof(query_string, model=None, prompt=None, llm_args={}):
-    
-    def inner_func(*args, **kwargs):
-        _model = model
-        _prompt = prompt
-        l_ret = asyncio.run(build_function(_model, _prompt, inner_func, query_string, args, kwargs, llm_args))
-        return l_ret
-
-    return inner_func
-
-
-async def build_function(model, prompt, inner_func, query_string, args, kwargs, llm_args):
-        _model = model
-        _prompt = prompt
-
-        if not hasattr(inner_func, "_infos"):
-            return_type = await guess_type(query_string, *args, **kwargs)
-
-            _infos = FunctionMetadata()
-            _infos.f_schema = {"type": f"{return_type.__name__}"}
-            _infos.f_def = f'''
-```python
-def lambda_function(*argument)->{return_type.__name__}:
-    """
-    {query_string}
-    """
-    ...
-```
-'''
-            _infos.f_call = [str(arg) for arg in args]
-            _infos.f_type = ([], return_type)
-            setattr(inner_func, "_infos", _infos)
-        else:
-            _infos = getattr(inner_func, "_infos")
-
-        prompt_data = gather_data_for_prompt_template(_infos)
-        prompt_data["PRE_FUNCTION_CALL"] = f"lambda_function(\"{'", "'.join(_infos.f_call) }\")"
-
-        if _model is None:
-            _model = DefaultModelPolicy.get_model()
-
-        if _prompt is None:
-            _prompt = DefaultModelPolicy.get_prompt()
-
-        prompt_rendered = _prompt.render(prompt_data)
-
-        logging_object = { 
-            "_last_request": {},
-            "_last_response": {}
-        }
-
-        setattr(inner_func, "_last_request", logging_object["_last_request"])
-
-        logging_object["_last_request"]['sys_prompt']=prompt_rendered
-        logging_object["_last_request"]['user_prompt']=prompt_data["PRE_FUNCTION_CALL"]
-        
-        try:
-            response_dict = await _model.api_call_async([
-                    {"role": "system", "content": prompt_rendered},
-                    {"role": "user", "content": prompt_data["PRE_FUNCTION_CALL"]}
-                ],
-                llm_args
-            )
-            
-            logging_object["_last_response"]["response_dict"] = response_dict
-            
-            l_ret = _model.response_parser(response_dict, _infos)
-            l_data = _model.type_returned_data(l_ret, _infos)
-
-            logging_object["_last_response"]["data"] = l_data
-            setattr(inner_func, "_last_response", logging_object["_last_response"])
-
-        except Exception as e:
-            raise RequestError(f"[thinkof] Cannot emulate the function.\n{e}")
-        return l_data