OpenHosta 2.2.2__tar.gz → 3.0.0__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: OpenHosta
-Version: 2.2.2
+Version: 3.0.0
 Summary: A lightweight library integrating LLM natively into Python
 Author: Léandre Ramos, Merlin Devillard, William Jolivet, Emmanuel Batt
 License: MIT License
@@ -56,12 +56,7 @@ License-File: LICENSE
 Requires-Dist: requests>=2.32.3
 Requires-Dist: typing_extensions>=4.12.2
 Requires-Dist: jinja2>=3.1.5
-Provides-Extra: all
-Requires-Dist: pydantic>=2.9.2; extra == "all"
-Requires-Dist: torch>=2.5.1; extra == "all"
-Requires-Dist: numpy>=2.1.3; extra == "all"
-Provides-Extra: pydantic
-Requires-Dist: pydantic>=2.8.2; extra == "pydantic"
+Requires-Dist: python-dotenv>=1.1.1
 Provides-Extra: dev
 Requires-Dist: mypy>=1.13.0; extra == "dev"
 Requires-Dist: isort>=5.13.2; extra == "dev"
@@ -75,28 +70,75 @@ Requires-Dist: pytest-cov>=5.0.0; extra == "tests"
 Requires-Dist: pillow>=11.0.0; extra == "tests"
 Requires-Dist: pydantic>=2.8.2; extra == "tests"
 Requires-Dist: Flask>=3.0.3; extra == "tests"
-Provides-Extra: predict
-Requires-Dist: torch>=2.5.1; extra == "predict"
-Requires-Dist: numpy>=2.1.3; extra == "predict"
+Dynamic: license-file
 
 # OpenHosta 
-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/>
-<a href="https://colab.research.google.com/github/hand-e-fr/OpenHosta/blob/main/docs/openhosta_phi4.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> Basic Usage - Synthetic Data - local LLM (phi-4)</a>
-<br/>
-<a href="https://colab.research.google.com/github/hand-e-fr/OpenHosta/blob/main/docs/openhosta_agent.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> Simple AI Agent with gpt-4o</a>
-<br/>Or have a look at [regression tests files](https://github.com/hand-e-fr/OpenHosta/tree/main/tests/non-regression) for multiples exemples.
+v3.0.0 - Integrates Inria Comments
 
-OpenHosta is a powerful Python tool designed to seamlessly integrate Large Language Models (LLMs) into development environments, enabling AI-powered function emulation that maintains native Python syntax and paradigms. Its strength lies in its simplicity and flexibility, allowing developers to easily create AI-enhanced applications while maintaining clean, Pythonic code structure.
+<br/>You can read the doc or directly have a look at [tests files](https://github.com/hand-e-fr/OpenHosta/tree/main/tests/) for multiples exemples.
 
-**- The future of development is human -**
+OpenHosta is a powerful Python extension designed to seamlessly integrate semantic capabilities seen in Large Language Models (LLMs) into tradictional development environments, enabling AI-powered function emulation that maintains native Python syntax and paradigms. Its strength lies in its simplicity and flexibility, allowing developers to easily create AI-enhanced applications while maintaining clean, Pythonic code structure.
+
+OpenHosta can run fully offline with a local model, or use a remote model via API key.
 
-Welcome to the OpenHosta documentation, a powerful tool that facilitates the integration LLM in the development environnement. OpenHosta is used to emulate functions using AI, while respecting Python's native paradygma and syntax.
+**- The future of development is human -**
 
 For this project, we have adopted a [Code of Conduct](https://github.com/hand-e-fr/OpenHosta/blob/main/CODE_OF_CONDUCT.md) to ensure a respectful and inclusive environment for all contributors. Please take a moment to read it.
 
+The simplest usage of OpenHosta is to allow semantic tests in your code, like this:
+
+```python
+from OpenHosta import test
+
+sentence = "You are an nice person."
+# You shall try with this too:
+# sentence = "You are a stupid #@!!~uk."
+
+if test(f"this contains an insult: {sentence}"):
+    print("The sentence is considered an insult.")
+else:
+    print("The sentence is not considered an insult.")
+
+# The sentence is not considered an insult.
+```
+
+But the most powerful feature of OpenHosta is the `emulate` function, which allows you to define a function with a docstring and let OpenHosta implement it for you using AI. The `emulate` function supports basic python types, dataclasses, pydantic, enums and Images. You can use all these types as input and output of the function (except for Images which can only be input).
+
+```python
+from OpenHosta import emulate
+
+from enum import Enum
+class DocumentType(Enum):
+    OLD_BOOK = "old_book"
+    ARTICLE = "article"
+    REPORT = "report"
+    THESIS = "thesis"
+
+from PIL.Image import Image, open
+
+def classify_document(page:Image)->DocumentType:
+    """
+    This function classifies the document based on the content of the page givent in parameter.
+    
+    Arguments:
+    page: An image of the document page to classify.
+
+    Returns:
+    DocumentType: The type of the document
+    """
+    return emulate()
+
+import requests
+url=r"https://www.inria.fr/sites/default/files/2024-01/A_outil_innovant_caracte%CC%81riser_plantes_1827x1026_bonnier-2.png"
+img = open(requests.get(url, stream=True).raw)
+
+result = classify_document(img)
+
+result
+# <DocumentType.OLD_BOOK: 'old_book'>
+```
+
 ## Table of Content
 
 - [OpenHosta](#openhosta)
@@ -121,17 +163,31 @@ pip install OpenHosta
 or
 
 ```sh
-git clone https://github.com/hand-e-fr/OpenHosta.git
+pip install https://github.com/hand-e-fr/OpenHosta.git
 ```
 
-**See the full installation guide [here](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/installation.md)**
+or for a specific branch
+
+```sh
+pip install "git+https://github.com/hand-e-fr/OpenHosta.git@unstable" # for the latest unstable version
+```
+
+**See the full [installation guide](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/installation.md)**
 
 ## Example
 
-```python
-from OpenHosta import emulate, config
+You shall set your API credentials either via environment variables or directly in your code.
+For now we assume that you have an OpenAI API key and that you have set it in .env like this:
+
+```env
+OPENHOSTA_DEFAULT_MODEL_NAME="gpt-4.1"
+OPENHOSTA_DEFAULT_MODEL_API_KEY="put-your-api-key-here"
+```
 
-config.set_default_apiKey("put-your-api-key-here")
+You can also use a local model using ollama. See [documentation](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/installation.md#local-models).
+
+```python
+from OpenHosta import emulate
 
 def translate(text:str, language:str)->str:
     """
@@ -140,9 +196,12 @@ def translate(text:str, language:str)->str:
     return emulate()
 
 result = translate("Hello World!", "French")
+
 print(result)
+# Bonjour le monde !
 ```
-You check OpenHosta's [documentation](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/doc.md) for more detailled informations or exemple
+
+You check [OpenHosta's documentation](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/doc.md) for more detailled informations or exemple
 
 ## Further information
 

openhosta-3.0.0/README.md

@@ -0,0 +1,166 @@
+# OpenHosta 
+
+v3.0.0 - Integrates Inria Comments
+
+<br/>You can read the doc or directly have a look at [tests files](https://github.com/hand-e-fr/OpenHosta/tree/main/tests/) for multiples exemples.
+
+OpenHosta is a powerful Python extension designed to seamlessly integrate semantic capabilities seen in Large Language Models (LLMs) into tradictional development environments, enabling AI-powered function emulation that maintains native Python syntax and paradigms. Its strength lies in its simplicity and flexibility, allowing developers to easily create AI-enhanced applications while maintaining clean, Pythonic code structure.
+
+OpenHosta can run fully offline with a local model, or use a remote model via API key.
+
+**- The future of development is human -**
+
+For this project, we have adopted a [Code of Conduct](https://github.com/hand-e-fr/OpenHosta/blob/main/CODE_OF_CONDUCT.md) to ensure a respectful and inclusive environment for all contributors. Please take a moment to read it.
+
+The simplest usage of OpenHosta is to allow semantic tests in your code, like this:
+
+```python
+from OpenHosta import test
+
+sentence = "You are an nice person."
+# You shall try with this too:
+# sentence = "You are a stupid #@!!~uk."
+
+if test(f"this contains an insult: {sentence}"):
+    print("The sentence is considered an insult.")
+else:
+    print("The sentence is not considered an insult.")
+
+# The sentence is not considered an insult.
+```
+
+But the most powerful feature of OpenHosta is the `emulate` function, which allows you to define a function with a docstring and let OpenHosta implement it for you using AI. The `emulate` function supports basic python types, dataclasses, pydantic, enums and Images. You can use all these types as input and output of the function (except for Images which can only be input).
+
+```python
+from OpenHosta import emulate
+
+from enum import Enum
+class DocumentType(Enum):
+    OLD_BOOK = "old_book"
+    ARTICLE = "article"
+    REPORT = "report"
+    THESIS = "thesis"
+
+from PIL.Image import Image, open
+
+def classify_document(page:Image)->DocumentType:
+    """
+    This function classifies the document based on the content of the page givent in parameter.
+    
+    Arguments:
+    page: An image of the document page to classify.
+
+    Returns:
+    DocumentType: The type of the document
+    """
+    return emulate()
+
+import requests
+url=r"https://www.inria.fr/sites/default/files/2024-01/A_outil_innovant_caracte%CC%81riser_plantes_1827x1026_bonnier-2.png"
+img = open(requests.get(url, stream=True).raw)
+
+result = classify_document(img)
+
+result
+# <DocumentType.OLD_BOOK: 'old_book'>
+```
+
+## Table of Content
+
+- [OpenHosta](#openhosta)
+  - [Table of Content](#table-of-content)
+  - [How to install OpenHosta ?](#how-to-install-openhosta-)
+  - [Example](#example)
+  - [Further information](#further-information)
+    - [Contributing](#contributing)
+    - [License](#license)
+    - [Authors \& Contact](#authors--contact)
+
+---
+
+## How to install OpenHosta ?
+
+You can install OpenHosta either via pip or via GitHub.
+
+```sh
+pip install OpenHosta
+```
+
+or
+
+```sh
+pip install https://github.com/hand-e-fr/OpenHosta.git
+```
+
+or for a specific branch
+
+```sh
+pip install "git+https://github.com/hand-e-fr/OpenHosta.git@unstable" # for the latest unstable version
+```
+
+**See the full [installation guide](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/installation.md)**
+
+## Example
+
+You shall set your API credentials either via environment variables or directly in your code.
+For now we assume that you have an OpenAI API key and that you have set it in .env like this:
+
+```env
+OPENHOSTA_DEFAULT_MODEL_NAME="gpt-4.1"
+OPENHOSTA_DEFAULT_MODEL_API_KEY="put-your-api-key-here"
+```
+
+You can also use a local model using ollama. See [documentation](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/installation.md#local-models).
+
+```python
+from OpenHosta import emulate
+
+def translate(text:str, language:str)->str:
+    """
+    This function translates the text in the “text” parameter into the language specified in the “language” parameter.
+    """
+    return emulate()
+
+result = translate("Hello World!", "French")
+
+print(result)
+# Bonjour le monde !
+```
+
+You check [OpenHosta's documentation](https://github.com/hand-e-fr/OpenHosta/blob/main/docs/doc.md) for more detailled informations or exemple
+
+## Further information
+
+### Contributing
+
+We warmly welcome contributions from the community. Whether you are an experienced developer or a beginner, your contributions are welcome.
+
+If you wish to contribute to this project, please refer to our [Contribution Guide](https://github.com/hand-e-fr/OpenHosta/blob/main/CONTRIBUTING.md) and our [Code of Conduct](https://github.com/hand-e-fr/OpenHosta/blob/main/CODE_OF_CONDUCT.md).
+
+Browse the existing [issues](https://github.com/hand-e-fr/OpenHosta/issues) to see if someone is already working on what you have in mind or to find contribution ideas.
+
+### License
+
+This project is licensed under the MIT License. This means you are free to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the software, subject to the following conditions:
+
+  - The text of the license below must be included in all copies or substantial portions of the software.
+
+See the [LICENSE](https://github.com/hand-e-fr/OpenHosta/blob/main/LICENSE) file for more details.
+
+### Authors & Contact
+
+For further questions or assistance, please refer to partner hand-e or contact us directly via github.
+
+**Authors**:
+   - Emmanuel Batt: Manager and Coordinator, Founder of Hand-e
+   - William Jolivet: DevOps, SysAdmin
+   - Léandre Ramos: IA developer
+   - Merlin Devillard: UX designer, Product Owner
+
+GitHub: https://github.com/hand-e-fr/OpenHosta
+
+---
+
+Thank you for your interest in our project and your potential contributions!
+
+**The OpenHosta Team**

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenHosta"
-version = "2.2.2"
+version = "3.0.0"
 description = "A lightweight library integrating LLM natively into Python"
 keywords = ["AI", "GPT", "Natural language", "Autommatic", "Easy"]
 authors = [
@@ -43,18 +43,11 @@ classifiers = [
 dependencies = [
     "requests>=2.32.3",
     "typing_extensions>=4.12.2",
-    "jinja2>=3.1.5"
+    "jinja2>=3.1.5",
+    "python-dotenv>=1.1.1"
 ]
 
 [project.optional-dependencies]
-all = [
-    "pydantic>=2.9.2",
-    "torch>=2.5.1",
-    "numpy>=2.1.3"
-]
-pydantic = [
-    "pydantic>=2.8.2"
-]
 dev = [ 
     "mypy>=1.13.0",
     "isort>=5.13.2",
@@ -70,10 +63,6 @@ tests = [
     "pydantic>=2.8.2",
     "Flask>=3.0.3"
 ]
-predict = [
-    "torch>=2.5.1",
-    "numpy>=2.1.3"
-]
 
 [project.urls]
 Homepage = "https://github.com/hand-e-fr/OpenHosta"

openhosta-3.0.0/src/OpenHosta/__init__.py

@@ -0,0 +1,44 @@
+__version__ = "3.0.0"
+
+from .core.config import config
+from .core.logger import print_last_prompt, print_last_decoding
+from .core.meta_prompt import MetaPrompt
+
+from .exec.ask import ask, ask_async
+from .exec.emulate import emulate, emulate_async
+from .exec.closure import closure, closure_async
+from .semantics.operators import test, test_async
+
+from .models import OpenAICompatibleModel as Model
+from .models import OpenAICompatibleModel
+
+from .core.config import reload_dotenv
+
+from .pipelines import Pipeline, OneTurnConversationPipeline
+
+import os
+
+DefaultModel = config.DefaultModel
+DefaultPipeline = config.DefaultPipeline
+
+all = (
+    "ask",
+    "ask_async",
+    "emulate",
+    "emulate_async",
+    "closure",
+    "closure_async",
+    "test",
+    "test_async",
+    "config",
+    "reload_dotenv",
+    "Model",
+    "DefaultModel",
+    "DefaultPipeline",
+    "OpenAICompatibleModel",
+    "MetaPrompt",
+    "print_last_prompt",
+    "print_last_decoding",
+    "Pipeline",
+    "OneTurnConversationPipeline"
+)

openhosta-3.0.0/src/OpenHosta/asynchrone/__init__.py

@@ -0,0 +1,12 @@
+from ..exec.ask import ask_async as ask
+from ..exec.emulate import emulate_async as emulate
+from ..exec.closure import closure_async as closure
+from ..semantics.operators import test_async as test
+
+
+all = (
+    "ask",
+    "emulate",
+    "closure",
+    "test",
+)

openhosta-3.0.0/src/OpenHosta/core/analizer.py

@@ -0,0 +1,172 @@
+
+import inspect
+from ..models import ModelCapabilities
+from ..core.type_converter import nice_type_name, describe_type_as_python, describe_type_as_schema, BASIC_TYPES
+
+def hosta_analyze_update(frame, inspection):
+    analyse = inspection["analyse"]
+    new_analyse = {
+        "name": analyse["name"],
+        "args": [],
+        "type": analyse["type"],
+        "doc":  analyse["doc"]
+    }
+    args_info = inspect.getargvalues(frame)
+    new_analyse["args"] = [{"name":a["name"], "value":args_info.locals[a["name"]], "type":a["type"]} for a in analyse["args"]] 
+    return new_analyse
+
+def hosta_analyze(frame=None, function_pointer=None):
+    sig = inspect.signature(function_pointer)
+
+    if frame is None:
+        result_args_value_table = []
+    else:
+        args_info = inspect.getargvalues(frame)
+        
+        result_args_value_table = [{
+            "name":arg, 
+            "value": args_info.locals[arg], 
+            "type":sig.parameters[arg].annotation} for arg in args_info.args]
+    
+    result_function_name = function_pointer.__name__
+    result_return_type = sig.return_annotation
+    result_docstring = function_pointer.__doc__
+
+    return {
+        "name": result_function_name,
+        "args": result_args_value_table,
+        "type": result_return_type,
+        "doc":  result_docstring
+    }
+
+
+def encode_function(analyse, model_capability=set([ModelCapabilities.TEXT2TEXT])):
+    """
+    Encode the function signature and docstring into a format suitable for the model.
+    """
+    snippets  = {}
+    snippets |= encode_function_documentation(analyse)
+    snippets |= encode_function_parameter_types(analyse)
+    snippets |= encode_function_parameter_values(analyse)
+    snippets |= encode_function_parameter_names(analyse)
+    snippets |= encode_function_return_type(analyse)
+    snippets |= encode_function_return_type_definition(analyse)
+    
+    return snippets
+
+def encode_function_documentation(analyse):
+        return {
+            "function_name" : analyse["name"], 
+            "function_doc"  : analyse["doc"],
+            }
+
+def encode_function_parameter_types(analyse):
+    
+    # Types of the arguments when type definition is too long
+    # to be included inline in the function call
+    json_schema_types_definition_list = {}    
+    
+    # Types of the arguments when type definition is too long
+    # to be included inline in the function call
+    python_types_definition_list = {}    
+    
+    for a in analyse["args"]:
+        arg_type = a["type"]
+        if arg_type is inspect._empty or arg_type in BASIC_TYPES:
+            # Basic types are assumed to be known by the model
+            # and are not included in the prompt
+            pass
+        else:
+            specifig_type_doc = describe_type_as_python(arg_type)
+            if not specifig_type_doc is None:
+                python_types_definition_list[nice_type_name(arg_type)] = specifig_type_doc
+                
+            specifig_type_json = describe_type_as_schema(arg_type)
+            if not specifig_type_json is None:
+                json_schema_types_definition_list[nice_type_name(arg_type)] = specifig_type_json
+
+    return {
+        "python_type_definition_dict":       "\n".join([f"```python\n# definition of type {k}:\n{v}\n```" for k,v in python_types_definition_list.items()]),
+        "json_schema_type_definition_dict":  "\n\n".join([f"# JSON Schema of type {k}:\n```json\n{v}\n```" for k,v in json_schema_types_definition_list.items()]),
+    }
+
+def encode_function_parameter_values(analyse):
+
+    args = analyse["args"]
+    
+    # Vaiable value definition when content is too long
+    # to be included inline in the function call
+    variable_definition_list = []
+    
+    # Call arguments for inline function call
+    call_string_list = []
+    
+    for a in args:
+        call_arg, value, arg_type = a["name"], a["value"], a["type"]
+
+        # Place long variables outside function definition. 
+        # math.pi is 17 char, I decide to cut at 20 
+        str_value = repr(value)
+        if len(str_value) > 20:
+            try:
+                import PIL
+                if isinstance(value, PIL.Image.Image):
+                    # Add a comment to explain that the image content is in the message
+                    str_value += f" # the real content of `{call_arg}` image is provided as an image in the message"
+            except:
+                # PIL is not available. It cannot be an image
+                pass
+            variable_definition_list += [call_arg+"="+str_value+"\n"]
+        else:
+            # We do not show default values as this could contradict values from call
+            # call_arg += " = "+str_value
+            call_arg += " = "+str_value
+        
+        call_string_list += [call_arg]
+        
+    return {
+        "variables_initialization":"\n\n".join(variable_definition_list),
+        "function_call_arguments":", ".join(call_string_list),
+    }
+
+def encode_function_parameter_names(analyse):
+
+    args = analyse["args"]
+    
+    # Inline argument names and typing if short enough
+    inline_string_list = []
+
+    # Vaiable value definition when content is too long
+    # to be included inline in the function call
+    variable_definition_list = []
+    
+    for a in args:
+        str_arg, arg_type = a["name"], a["type"]
+        if arg_type is inspect._empty:
+            pass
+        else:
+            str_arg += ": "+nice_type_name(arg_type) 
+
+        inline_string_list += [str_arg]
+
+
+    return {
+        "function_return_type": " -> " + nice_type_name(analyse["type"]) if analyse["type"] else "",
+        "function_args":", ".join(inline_string_list),
+        "function_inline_variable_declaration":"\n".join(variable_definition_list),
+    }
+
+
+def encode_function_return_type(analyse):
+    return {
+        "function_return_type": analyse["type"],
+        "function_return_type_name": nice_type_name(analyse["type"]),
+    }
+    
+def encode_function_return_type_definition(analyse):
+
+    return {
+        "function_return_as_python_type" : describe_type_as_python(analyse["type"]),
+        "function_return_as_json_schema" : describe_type_as_schema(analyse["type"]),
+        }
+