OpenHosta 1.0.1__tar.gz

openhosta-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 hand-e
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openhosta-1.0.1/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.1
+Name: OpenHosta
+Version: 1.0.1
+Summary: Open-Source programming project IA integretion in developement environnement
+Author: Léandre Ramos, Merlin Devillard, William Jolivet, Emmanuel Batt
+License: MIT License
+        
+        Copyright (c) 2024 hand-e
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/hand-e-fr/OpenHosta
+Project-URL: Issues, https://github.com/hand-e-fr/OpenHosta/issues
+Keywords: AI,GPT,Natural language,Autommatic,Easy
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: French
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32.3
+Requires-Dist: pydantic>=2.8.2
+Requires-Dist: tiktoken>=0.7.0
+
+# OpenHosta 
+v1.0 - Open-Source Project
+
+**- The future of development is human -**
+
+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.
+
+For this project, we have adopted a [Code of Conduct](CODE_OF_CONDUCT.md) to ensure a respectful and inclusive environment for all contributors. Please take a moment to read it.
+
+## Table of Content
+
+- [OpenHosta](#openhosta)
+  - [Table of Content](#table-of-content)
+  - [How to install OpenHosta ?](#how-to-install-openhosta-)
+    - [Prerequisites](#prerequisites)
+    - [Installation](#installation)
+      - [Via pip](#via-pip)
+      - [Via git (Developper version)](#via-git-developper-version)
+    - [Example](#example)
+  - [Further information](#further-information)
+    - [Contributing](#contributing)
+    - [License](#license)
+    - [Authors \& Contact](#authors--contact)
+
+---
+
+## How to install OpenHosta ?
+
+### Prerequisites
+
+1. **Python 3.8+**
+   - Download and install Python from [python.org](https://www.python.org/downloads/).
+
+2. **pip**
+   - pip is generally included with Python. Verify its installation with:
+     ```sh
+     pip --version
+     ```
+
+3. **Git**
+   - Download and install Git from [git-scm.com](https://git-scm.com/downloads).
+
+4. **Virtual Environment (optional)**
+   - Create and activate a virtual environment:
+     ```bash
+     python -m venv env
+     ```
+   - Activate the virtual environement:
+      ```bash
+      .\env\Scripts\activate # Windows
+      source env/bin/activate # macOS/Linux
+      ```
+
+5. **API Key**
+   - **API Key**: Log in to your OpenAI account from [openai.com](https://openai.com/), then create your API key. For further information, you can check this [tuto](https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key).
+
+### Installation
+
+#### Via pip
+
+1. Run the following command to install OpenHosta directly:
+ 
+```sh
+pip install openhosta
+```
+
+2. After the installation, you can verify that OpenHosta is installed correctly by running:
+
+```sh
+pip show openhosta
+```
+
+#### Via git (Developper version)
+
+1. Clone the **Git repository** to your local machine using the following command:
+
+```bash
+git clone git@github.com:hand-e-fr/OpenHosta-dev.git
+```
+
+2. Navigate to the **directory** of the cloned project:
+
+```bash
+cd OpenHosta-dev
+```
+
+3. Ensure you have installed the necessary **dependencies** before starting.
+
+```bash
+pip install -r requirements.txt
+```
+
+This way you have all the documentation and source code to understand our project
+
+### Example
+
+```python
+from openhosta import *
+
+config.set_default_apiKey("example-apikey")
+
+def my_func(a:int, b:str)->dict:
+   """
+   This Function does something.
+   """
+   return emulate()
+
+my_func(5, "Hello World!")
+
+my_lambda = thought("Do something")
+my_lambda(5)
+```
+You check OpenHosta's [documentation](doc/Docs.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](CONTRIBUTING.md) and our [Code of Conduct](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](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: MLOps, 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-1.0.1/README.md

@@ -0,0 +1,149 @@
+# OpenHosta 
+v1.0 - Open-Source Project
+
+**- The future of development is human -**
+
+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.
+
+For this project, we have adopted a [Code of Conduct](CODE_OF_CONDUCT.md) to ensure a respectful and inclusive environment for all contributors. Please take a moment to read it.
+
+## Table of Content
+
+- [OpenHosta](#openhosta)
+  - [Table of Content](#table-of-content)
+  - [How to install OpenHosta ?](#how-to-install-openhosta-)
+    - [Prerequisites](#prerequisites)
+    - [Installation](#installation)
+      - [Via pip](#via-pip)
+      - [Via git (Developper version)](#via-git-developper-version)
+    - [Example](#example)
+  - [Further information](#further-information)
+    - [Contributing](#contributing)
+    - [License](#license)
+    - [Authors \& Contact](#authors--contact)
+
+---
+
+## How to install OpenHosta ?
+
+### Prerequisites
+
+1. **Python 3.8+**
+   - Download and install Python from [python.org](https://www.python.org/downloads/).
+
+2. **pip**
+   - pip is generally included with Python. Verify its installation with:
+     ```sh
+     pip --version
+     ```
+
+3. **Git**
+   - Download and install Git from [git-scm.com](https://git-scm.com/downloads).
+
+4. **Virtual Environment (optional)**
+   - Create and activate a virtual environment:
+     ```bash
+     python -m venv env
+     ```
+   - Activate the virtual environement:
+      ```bash
+      .\env\Scripts\activate # Windows
+      source env/bin/activate # macOS/Linux
+      ```
+
+5. **API Key**
+   - **API Key**: Log in to your OpenAI account from [openai.com](https://openai.com/), then create your API key. For further information, you can check this [tuto](https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key).
+
+### Installation
+
+#### Via pip
+
+1. Run the following command to install OpenHosta directly:
+ 
+```sh
+pip install openhosta
+```
+
+2. After the installation, you can verify that OpenHosta is installed correctly by running:
+
+```sh
+pip show openhosta
+```
+
+#### Via git (Developper version)
+
+1. Clone the **Git repository** to your local machine using the following command:
+
+```bash
+git clone git@github.com:hand-e-fr/OpenHosta-dev.git
+```
+
+2. Navigate to the **directory** of the cloned project:
+
+```bash
+cd OpenHosta-dev
+```
+
+3. Ensure you have installed the necessary **dependencies** before starting.
+
+```bash
+pip install -r requirements.txt
+```
+
+This way you have all the documentation and source code to understand our project
+
+### Example
+
+```python
+from openhosta import *
+
+config.set_default_apiKey("example-apikey")
+
+def my_func(a:int, b:str)->dict:
+   """
+   This Function does something.
+   """
+   return emulate()
+
+my_func(5, "Hello World!")
+
+my_lambda = thought("Do something")
+my_lambda(5)
+```
+You check OpenHosta's [documentation](doc/Docs.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](CONTRIBUTING.md) and our [Code of Conduct](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](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: MLOps, 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-1.0.1/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "OpenHosta"
+version = "1.0.1"
+description = "Open-Source programming project IA integretion in developement environnement"
+keywords = ["AI", "GPT", "Natural language", "Autommatic", "Easy"]
+authors = [
+  { name="Léandre Ramos"},
+  { name="Merlin Devillard"},
+  { name="William Jolivet"},
+  { name="Emmanuel Batt"},
+]
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3.8",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Natural Language :: French",
+    "Topic :: Software Development :: Code Generators"
+]
+dependencies = [
+  "requests>=2.32.3",
+  "pydantic>=2.8.2",
+  "tiktoken>=0.7.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/hand-e-fr/OpenHosta"
+Issues = "https://github.com/hand-e-fr/OpenHosta/issues"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"OpenHosta" = ["*.json"]

openhosta-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

openhosta-1.0.1/src/OpenHosta/__init__.py

@@ -0,0 +1 @@
+from .openhosta import *

openhosta-1.0.1/src/OpenHosta/analytics.py

@@ -0,0 +1,145 @@
+import tiktoken
+from enum import Enum
+import time as t
+import sys
+import requests
+import json
+
+from .config import Model, _default_model
+from .prompt import PromptMananger
+
+_x = PromptMananger()
+
+_estimate_prompt = _x.get_prompt("estimate")
+
+
+class ModelAnalizer(Model):
+
+    _default_input_cost: int = 0.005
+    _default_output_cost: int = 0.015
+    _default_token_perSec = 63.32
+    _default_latency = 0.48
+
+    def __init__(
+        self,
+        name: str,
+        input_cost: float,
+        output_cost: float,
+        latency: float,
+        token_perSec: float,
+    ):
+        self.name = self._default_name if name is None else name
+        self.input_cost = self._default_input_cost if input_cost is None else input_cost
+        self.output_cost = (
+            self._default_output_cost if output_cost is None else output_cost
+        )
+        self.latency = self._default_latency if latency is None else latency
+        self.token_perSec = (
+            self._default_token_perSec if token_perSec is None else token_perSec
+        )
+        self.tokenizer = tiktoken.get_encoding("cl100k_base")
+
+    def get_input_cost(self):
+        return self.input_cost
+
+    def get_output_cost(self):
+        return self.output_cost
+
+    def get_latency(self):
+        return self.latency
+
+    def get_token_perSec(self):
+        return self.token_perSec
+
+    def _estimate_output_token(self, function_doc: str, function_call: str):
+        global _estimate_prompt, _default_model
+
+        try:
+            if not _estimate_prompt:
+                raise ValueError("ValueError -> emulate empty values")
+        except ValueError as v:
+            sys.stderr.write(f"[ESTIMATE_ERROR]: {v}")
+            return None
+
+        api_key = _default_model.api_key
+        l_body = {
+            "model": _default_model.model,
+            "messages": [
+                {
+                    "role": "system",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": _estimate_prompt
+                            + "---\n"
+                            + str(function_doc)
+                            + "\n---",
+                        }
+                    ],
+                },
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": str(function_call)}],
+                },
+            ],
+            "response_format": {"type": "json_object"},
+            "temperature": 0.1,
+            "top_p": 0.1,
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}",
+        }
+
+        response = requests.post(_default_model.base_url, json=l_body, headers=headers)
+
+        if response.status_code == 200:
+            data = response.json()
+            json_string = data["choices"][0]["message"]["content"]
+            try:
+                l_ret_data = json.loads(json_string)
+
+            except json.JSONDecodeError as e:
+                sys.stderr.write(f"JSONDecodeError: {e}")
+                l_cleand = "\n".join(json_string.split("\n")[1:-1])
+                l_ret_data = json.loads(l_cleand)
+
+            l_ret = l_ret_data["tokens"]
+        else:
+            sys.stderr.write(f"Error {response.status_code}: {response.text}")
+            l_ret = None
+
+        return l_ret
+
+    def _compute_request_cost(self, input_text, output_token):
+        input_tokens = self.tokenizer.encode(input_text)
+        num_input_tokens = len(input_tokens)
+        num_output_tokens = output_token
+        cost_input = (num_input_tokens / 1000) * self.input_cost
+        cost_output = (num_output_tokens / 1000) * self.output_cost
+        total_cost = cost_input + cost_output
+        return total_cost
+
+    def _compute_request_duration(self, output_token):
+        total = self.latency
+        total += self.token_perSec / output_token
+        total += 0.5  # Processing duration margin
+        return total
+
+
+def request_timer(func):
+    def wrapper(*args, **kwargs):
+        g_c = "\033[94m"
+        n = "\033[0m"
+        bold = "\033[1m"
+
+        start = t.time()
+        rv = func(*args, **kwargs)
+        end = t.time()
+
+        duration = end - start
+        print(f"{g_c}{bold}Execution time of {func.__name__}: {duration:.2f}s{n}")
+        return rv
+
+    return wrapper

openhosta-1.0.1/src/OpenHosta/config.py

@@ -0,0 +1,122 @@
+import sys
+import requests
+import json
+import re
+
+
+def is_valid_url(url):
+    regex = re.compile(
+        r"^(?:http|ftp)s?://"
+        r"(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|"
+        r"localhost|"
+        r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|"
+        r"\[?[A-F0-9]*:[A-F0-9:]+\]?)"
+        r"(?::\d+)?"
+        r"(?:/?|[/?]\S+)$",
+        re.IGNORECASE,
+    )
+    return re.match(regex, url) is not None
+
+
+class Model:
+
+    _SYS_PROMPT = ""
+
+    def __init__(self, model: str = None, base_url: str = None, api_key: str = None):
+        self.model = model
+        self.base_url = base_url
+        self.api_key = api_key
+
+        if any(var is None for var in (model, base_url)):
+            sys.stderr.write(f"[CONFIG_ERROR] Empty values.")
+            return
+        elif not is_valid_url(self.base_url):
+            sys.stderr.write(f"[CONFIG_ERROR Invalid URL.")
+            return
+
+    def __str__(self) -> str:
+        return (
+            f"[OpenHosta] <{self.__class__.__module__}.{self.__class__.__name__} object at {hex(id(self))}>\n"
+            f"Model: {self.model}\n"
+            f"Base_url: {self.base_url}\n"
+            "Infos:\n"
+        )
+
+    def _api_call(
+        self, sys_prompt: str, user_prompt: str, creativity: float, diversity: float
+    ):
+        if self.api_key is None or not self.api_key:
+            sys.stderr.write(f"[CALL_ERROR] Unknown API key.")
+            return
+
+        l_body = {
+            "model": self.model,
+            "messages": [
+                {
+                    "role": "system",
+                    "content": [{"type": "text", "text": str(sys_prompt)}],
+                },
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": str(user_prompt)}],
+                },
+            ],
+            "response_format": {"type": "json_object"},
+            "temperature": creativity if creativity is not None else 0.7,
+            "top_p": diversity if diversity is not None else 0.7,
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        try:
+            response = requests.post(self.base_url, json=l_body, headers=headers)
+        except Exception as e:
+            pass
+        if response.status_code != 200:
+            sys.stderr.write(f"[CALL_ERROR] API call the request was unsuccessful.")
+        return response
+
+    def _request_handler(self, response):
+        l_ret = ""
+
+        data = response.json()
+        json_string = data["choices"][0]["message"]["content"]
+        
+        
+        try:
+            l_ret_data = json.loads(json_string)
+
+        except json.JSONDecodeError as e:
+            sys.stderr.write(f"JSONDecodeError: {e}")
+            l_cleand = "\n".join(json_string.split("\n")[1:-1])
+            l_ret_data = json.loads(l_cleand)
+
+        l_ret = l_ret_data["return"]
+
+        return l_ret
+
+
+_default_model = Model(
+    model="gpt-4o",
+    base_url="https://api.openai.com/v1/chat/completions",
+)
+
+
+def set_default_model(new: Model):
+    global _default_model
+
+    _default_model = new
+
+
+def set_default_apiKey(api_key=None):
+    global _default_model
+
+    if api_key is not None or isinstance(api_key, str):
+        _default_model.api_key = api_key
+    else:
+        sys.stderr.write("[CONFIG_ERROR] Invalid API key.")
+
+
+__all__ = Model, _default_model, set_default_model, set_default_apiKey

openhosta-1.0.1/src/OpenHosta/emulate.py

@@ -0,0 +1,75 @@
+import sys
+
+from .analytics import request_timer
+from .prompt import PromptMananger
+from .config import _default_model, Model, set_default_apiKey
+
+_x = PromptMananger()
+
+_emulator_pre_prompt = _x.get_prompt("emulate")
+
+
+def _exec_emulate(
+    _function_doc=None,
+    _function_call=None,
+    _function_return=None,
+    model: Model = _default_model,
+    warn: bool = False,
+    l_creativity: float = None,
+    l_diversity: float = None,
+):
+    global _emulator_pre_prompt
+
+    try:
+        if not isinstance(_emulator_pre_prompt, str) or not _emulator_pre_prompt:
+            raise ValueError("Invalid prompt.")
+        if (l_creativity is not None and (l_creativity < 0 or l_creativity > 1)) or (
+            l_diversity is not None and (l_diversity < 0 or l_diversity > 1)
+        ):
+            raise ValueError("Emulate out of range values (0<creativity|diversity<1)")
+    except ValueError as v:
+        sys.stderr.write(f"[EMULATE_ERROR]: {v}")
+        return None
+
+    l_user_prompt = (
+        "Here's the function definition:\n"
+        + _function_doc
+        + "\nAnd this is the function call:\n"
+        + _function_call
+    )
+    
+    if not _function_return is None:
+        l_user_prompt = (
+            l_user_prompt 
+            + "\nTo fill the “return” value in the output JSON, build your response as defined in the following JSON schema. Do not change the key \"return\"\n"
+            + str(_function_return)
+        )
+
+    response = model._api_call(
+        sys_prompt=_emulator_pre_prompt,
+        user_prompt=l_user_prompt,
+        creativity=l_creativity,
+        diversity=l_diversity,
+    )
+
+    l_ret = ""
+
+    if response.status_code == 200:
+        l_ret = model._request_handler(response)
+    else:
+        sys.stderr.write(f"Error {response.status_code}: {response.text}")
+        l_ret = None
+    return l_ret
+
+
+def thought(key):
+    def inner_func(*args, **kwargs):
+        try:
+            result = _exec_emulate(_function_doc=key, _function_call=str(args[0]))
+        except Exception as e:
+            sys.stderr.write(Exception)
+            sys.stderr.write("[LMDA_ERROR]")
+            result = None
+        return result
+
+    return inner_func

openhosta-1.0.1/src/OpenHosta/enhancer.py

@@ -0,0 +1,123 @@
+import requests
+import json
+import sys
+
+from .prompt import PromptMananger
+from .config import _default_model
+
+_x = PromptMananger()
+_enhancer_pre_prompt = _x.get_prompt("enhance")
+
+
+def _ai_call_enh(sys_prompt: str, func_prot: str, func_doc: str):
+    global _default_model
+
+    api_key = _default_model.api_key
+    url = _default_model.base_url
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}",
+    }
+
+    data = {
+        "model": _default_model.model,
+        "messages": [
+            {"role": "system", "content": [{"type": "text", "text": sys_prompt}]},
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "\nHere's my python function's prototype:\n---\n"
+                        + func_prot
+                        + "\n---\n",
+                    }
+                ],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "\nHere's my python function's prompt:\n---\n"
+                        + func_doc
+                        + "\n---\n",
+                    }
+                ],
+            },
+        ],
+        "temperature": 0.7,
+        "top_p": 0.7,
+    }
+
+    response = requests.post(url, headers=headers, data=json.dumps(data))
+
+    if response.status_code == 200:
+        response_data = response.json()
+        return response_data["choices"][0]["message"]["content"]
+    else:
+        sys.stderr.write(
+            "[CALL_ERROR] The request was unsuccessful or one of the parameters is invalid"
+        )
+        sys.stderr.write(f"Status: {response.status_code}")
+        return None
+
+
+def _parse_data(response: str, last_enh: dict) -> dict:
+    current_section = None
+    current_text = []
+
+    for line in response.splitlines():
+        if line.startswith("->"):
+            if current_section:
+                last_enh[current_section] = "\n".join(current_text).strip()
+            current_section = line[3:].strip(":")
+            current_text = []
+        else:
+            current_text.append(line)
+    if current_section:
+        last_enh[current_section] = "\n".join(current_text).strip()
+    return last_enh
+
+
+def _build_attributes(func: object, last_enh) -> int:
+    try:
+        if not func.__name__ and not type(func.__name__) is str:
+            raise ValueError("ValueError -> function name")
+        if not last_enh["enhanced"] and not type(last_enh["enhanced"]) is str:
+            raise ValueError("ValueError -> enhanced output")
+        if not last_enh["review"] and not type(last_enh["review"]) is str:
+            raise ValueError("ValueError -> review output")
+        if not last_enh["advanced"] and not type(last_enh["advanced"]) is str:
+            raise ValueError("ValueError -> seggested output")
+        if not last_enh["mermaid"] and not type(last_enh["mermaid"]) is str:
+            raise ValueError("ValueError -> mermaid output")
+    except ValueError as e:
+        sys.stderr.write(f"[BUILD_ERROR] {e}")
+        return -1
+    finally:
+        func.enhanced_prompt = last_enh["enhanced"]
+        func.review = last_enh["review"]
+        func.advanced = last_enh["advanced"]
+        func.diagramm = last_enh["mermaid"]
+    return 0
+
+
+def enhance(func):
+    global _enhancer_pre_prompt
+
+    last_enh: dict = {
+        "enhanced": None,
+        "review": None,
+        "advanced": None,
+        "mermaid": None,
+    }
+
+    func_name, func_doc = func.__name__, func.__doc__
+
+    last_return = _ai_call_enh(_enhancer_pre_prompt, func._prot, func_doc)
+
+    last_enh = _parse_data(last_return, last_enh)
+
+    _build_attributes(func, last_enh)

openhosta-1.0.1/src/OpenHosta/errors.py

@@ -0,0 +1,8 @@
+class OhCustomError(Exception):
+    """Base class for other customs exceptions"""
+    pass
+    
+class RequestError(OhCustomError):
+    """Raised when a request to a llm went wrong"""
+    pass
+    

openhosta-1.0.1/src/OpenHosta/exec.py

@@ -0,0 +1,114 @@
+import inspect
+import sys
+from typing import Callable, Any, Dict
+from pydantic import BaseModel, create_model
+
+from .enhancer import enhance
+
+
+class HostaInjector:
+
+    def __init__(self, exec):
+        if not callable(exec):
+            raise TypeError("Executive function must be a function.")
+        self.exec = exec
+
+    def __call__(self, *args, **kwargs):
+        infos = {"def": "", "call": "", "return_type": ""}
+
+        func_obj, caller = self._extend_scope()
+        infos["def"], func_prot = self._get_functionDef(func_obj)
+        infos["call"] = self._get_functionCall(func_obj, caller)
+        infos["return_type"] = self._get_functionReturnType(func_obj)
+
+        self._attach_attributs(func_obj, func_prot)
+        return self.exec(
+            infos["def"], infos["call"], infos["return_type"], *args, **kwargs
+        )
+
+    def _extend_scope(self) -> Callable:
+        try:
+            x = inspect.currentframe()
+            caller = x.f_back.f_back
+            name = caller.f_code.co_name
+            func = caller.f_globals.get(name)
+
+            if func is None:
+                raise Exception("Scope can't be extend.")
+            if not callable(func):
+                raise Exception("Larger scope isn't a callable.")
+        except Exception as e:
+            sys.stderr.write(f"[FRAME_ERROR]: {e}")
+            return None
+        return func, caller
+
+    def _get_functionDef(self, func: Callable) -> str:
+        sig = inspect.signature(func)
+
+        func_name = func.__name__
+        func_params = ", ".join(
+            [
+                (
+                    f"{param_name}: {param.annotation.__name__}"
+                    if param.annotation != inspect.Parameter.empty
+                    else param_name
+                )
+                for param_name, param in sig.parameters.items()
+            ]
+        )
+        func_return = (
+            f" -> {sig.return_annotation.__name__}"
+            if sig.return_annotation != inspect.Signature.empty
+            else ""
+        )
+        definition = f"def {func_name}({func_params}):{func_return}\n    '''\n    {func.__doc__}\n    '''"
+        prototype = f"def {func_name}({func_params}):{func_return}"
+        return definition, prototype
+
+    def _get_functionCall(self, func: Callable, caller) -> str:
+        args, _, _, values = inspect.getargvalues(caller)
+
+        sig = inspect.signature(func)
+        bound_args = {}
+        bound_args = sig.bind_partial(**values)
+        bound_args.apply_defaults()
+
+        args_str = ", ".join(
+            f"{name}={value!r}" if name in bound_args.kwargs else f"{value!r}"
+            for name, value in bound_args.arguments.items()
+        )
+
+        call = f"{func.__name__}({args_str})"
+        return call
+
+    def _inspect_returnType(self, func: Callable) -> str:
+        sig = inspect.signature(func)
+
+        if sig.return_annotation != inspect.Signature.empty:
+            return sig.return_annotation
+        else:
+            return None
+
+    def _get_functionReturnType(self, func: Callable) -> Dict[str, Any]:
+        return_type = self._inspect_returnType(func)
+        return_json = None
+
+        if return_type is not None:
+            if issubclass(return_type, BaseModel):
+                return_json = return_type.model_json_schema()
+            else:
+                new_model = create_model(
+                    "Hosta_return_specified", return_hosta_type=(return_type, ...)
+                )
+                return_json = new_model.model_json_schema()
+        else:
+            No_return_specified = create_model(
+                "Hosta_return_no_specified", return_hosta_type=(Any, ...)
+            )
+            return_json = No_return_specified.model_json_schema()
+
+        return return_json
+
+    def _attach_attributs(self, func: Callable, prototype: str):
+        func.__suggest__ = enhance
+        func._prot = prototype

openhosta-1.0.1/src/OpenHosta/openhosta.py

@@ -0,0 +1,9 @@
+from .emulate import _exec_emulate, thought
+import config
+from .config import Model
+from .exec import HostaInjector
+
+
+emulate = HostaInjector(_exec_emulate)
+
+__all__ = "emulate", "thought", "config", "Model"

openhosta-1.0.1/src/OpenHosta/prompt.json

@@ -0,0 +1,22 @@
+{
+    "prompts": [
+        {
+            "key": "emulate",
+            "text": "You will act as an emulator of impossible-to-code functions. I will provide you with the description of the function using Python's way of declaring functions, but I won't provide the function body as I don't know how to code it. It might even be impossible to code. Therefore, you should not try to write the body. Instead, directly imagine the function output.\n\nIn the conversation, I will directly write the function call as if it was called in Python. You should directly answer with whatever you believe would be a good return for the function.\n\nWhen you produce an answer, you should estimate the confidence level:\n\n    \"low\": You did your best, but with the provided description and your knowledge, you are not confident about the answer.\n    \"medium-instance\": You did your best, and with the provided description and your knowledge, you are pretty sure this answer is valid but not the only valid answer.\n    \"medium-unique\": You did your best, and with the provided description and your knowledge, you are pretty sure this answer is the unique and valid answer.\n    \"high-instance\": You did your best, and you are sure that your provided answer is a valid answer. It is a well-known function or you can easily implement a Python code that yields elements from the list of valid answers. This answer is randomly chosen from the list of valid answers.\n    \"high-unique\": You did your best, and you are sure that your provided answer is the unique valid answer. It is a well-known function or you can easily implement a Python code that solves the question and calculates this answer given this input.\n\nIf the output is documented as a Python structure, you should translate it to JSON.\nYou should encode the return in valid JSON format, without comments, using the following format:\n{\"return\":..., \"confidence\":...}\n\nThe output must be of the same type as that specified in the function call.\n\nAny assumptions made should be reasonable based on the provided function description and should take into account the error handling of the function.\n\nConsistency in the confidence levels is important to ensure accurate responses.\nThis is the function documentation:\n\nExample function call:\n\ndef example_function(a: int, b: dict) -> int:\n    \"\"\"\n    \"\"\"\n    This is an example function.\n    It adds two numbers.\n    \"\"\"\n    \"\"\"\n    pass\n\nExample imagined function output:\n\nresult = example_function(3, {\"value\": 7})\n\nExpected JSON output:\n\n{\"return\": 10, \"confidence\": \"medium-unique\"}\n\nThis is the function documentation:",
+            "category": "executive",
+            "version": "v1.0"
+        },
+        {
+            "key": "enhance",
+            "text": "I want you to become my Expert Prompt Creator for developer. Your goal is to help me craft the best possible prompt for my programming needs. The prompt you provide should be written from the perspective of me making the request to GPT-4o. Consider in your prompt creation that this prompt will be entered into an interface for GPT-4o. Apart from diagrams, you must write in text, without following any syntax. The process is as follows: You will generate the following sections:\n -> enhanced:\n{provide the best possible prompt according to my request. The prompt is used to describe a function to be performed in Python as precisely as possible. You can add error handling, as the function needs it to work properly. But don't code the function in the prompt. The prompt should not tell to create the function, but describe how it works.}\n-> review:\n{provide a concise paragraph on how to improve the prompt. Be very critical in your response. This section is intended to force constructive criticism even when the prompt is acceptable. Any assumptions and or issues should be included. Don't forget that you speak to a developer}\n-> advanced:\n{rewrite the prompt with the suggested improvements you made in the critique category. The aim is to make a proposal, an example. Make logical assumptions to solve the problem based on the context and all the information you have. You have to respond to the problems you formulated in the previous category. But don't code the function in the prompt.}\n-> mermaid:\n{Make a mermaid diagram explaining the function described by the prompt. You need to break the reasoning into several steps for ease of understanding and clarity. You must make it logical and easy to look at. You have to write it in mermaid syntax. You must not use the markdown syntax}\n",
+            "category": "analytics",
+            "version": "v1.0"
+        },
+        {
+            "key": "estimate",
+            "text": "You're a prompt engineering engineer tasked with estimating the number of output tokens an AI would return when executing a given function.\nThe functions are written in Python, so function returns must use Python typing.\n\nEach time, I'll give you the following elements:\n- The definition of the function.\n- Its call with arguments.\n- The function's docstring.\n\nYou need to take all these elements into account when formulating your answer.\nTo estimate the output token, you need to use a tokenization algorithm: take the one in GPT-3.\n\nTo make your estimate, you need to go through this chain of thought:\n\n1. Understand the Function.\n\t- With the given definition, the function prototype and its docstring.\n2. Analyze the Function Call.\n\t- With the function name and arguments provided.\n3. Guess the expected result without calculating it.\n\t- You MUST NOT calculate the result of the function.\n\t- Simply make a prediction with all the elements you have at your disposal.\n\t- Pay attention to the type of output. If it's not specified in the function prototype, then guess it based on the description and type of the input arguments.\n4. Estimate the number of tokens.\n\t- Use the information you have available for this step.\n\t- If the estimate is complex or impossible, make a realistic prediction using the context elements.\n5. Formulate your answer\n\t- Synthesize your answer into a single number.\n\t- Follow the answer format I'll give you below\n\nYou should encode your response in valid JSON format, without comments, using the following format:\n{ “tokens”:...}\nYour answer in the “tokens” category must be a number only.\nNothing should appear other than this JSON structure.\n\nAny assumptions made should be reasonable based on the provided function description and should take into account the error handling of the function.\n\nI'll give you an example:\nFunction definition:\n```python\ndef reverse_string(a:str)->str:\n\t\"\"\"\n\tThis function reverse the string in parameter.\n\t\"\"\"\n\treturn emulate()\n```\n\nFunction call:\n```python\nreverse_string(\"Hello World!\")\n```\n\nExcpected output:\n```\n{\"tokens\": 13}\n```\n\nHere's all the function documentation for you to estimate:",
+            "category": "analytics",
+            "version": "v1.0"
+        }
+    ]
+}

openhosta-1.0.1/src/OpenHosta/prompt.py

@@ -0,0 +1,41 @@
+import os
+import json
+import sys
+
+
+class PromptMananger:
+    def __init__(self, json_path=None):
+        if json_path is None:
+            try:
+                self.path = os.path.join(os.path.dirname(__file__), "prompt.json")
+            except Exception as e:
+                self.path = ""
+                sys.stderr.write(f"[JSON_ERROR] Impossible to find prompt.json:\n{e}")
+                return
+        else:
+            self.path = json_path
+
+        try:
+            with open(self.path, "r", encoding="utf-8") as file:
+                self.json = json.load(file)
+                self.prompts = {item["key"]: item for item in self.json["prompts"]}
+        except FileNotFoundError:
+            sys.stderr.write(f"[JSON_ERROR] File not found: {self.path}\n")
+            self.prompts = {}
+        except json.JSONDecodeError as e:
+            sys.stderr.write(f"[JSON_ERROR] JSON decode error:\n{e}\n")
+            self.prompts = {}
+
+    def get_prompt(self, key):
+        prompt = self.prompts.get(key)
+        if prompt:
+            return prompt["text"]
+        sys.stderr.write(f"[JSON_ERROR] Prompt not found\n")
+        return None
+
+    def get_prompt_details(self, key):
+        prompt = self.prompts.get(key)
+        if prompt:
+            return prompt
+        sys.stderr.write(f"[JSON_ERROR] Prompt not found\n")
+        return None

openhosta-1.0.1/src/OpenHosta.egg-info/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.1
+Name: OpenHosta
+Version: 1.0.1
+Summary: Open-Source programming project IA integretion in developement environnement
+Author: Léandre Ramos, Merlin Devillard, William Jolivet, Emmanuel Batt
+License: MIT License
+        
+        Copyright (c) 2024 hand-e
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/hand-e-fr/OpenHosta
+Project-URL: Issues, https://github.com/hand-e-fr/OpenHosta/issues
+Keywords: AI,GPT,Natural language,Autommatic,Easy
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: French
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32.3
+Requires-Dist: pydantic>=2.8.2
+Requires-Dist: tiktoken>=0.7.0
+
+# OpenHosta 
+v1.0 - Open-Source Project
+
+**- The future of development is human -**
+
+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.
+
+For this project, we have adopted a [Code of Conduct](CODE_OF_CONDUCT.md) to ensure a respectful and inclusive environment for all contributors. Please take a moment to read it.
+
+## Table of Content
+
+- [OpenHosta](#openhosta)
+  - [Table of Content](#table-of-content)
+  - [How to install OpenHosta ?](#how-to-install-openhosta-)
+    - [Prerequisites](#prerequisites)
+    - [Installation](#installation)
+      - [Via pip](#via-pip)
+      - [Via git (Developper version)](#via-git-developper-version)
+    - [Example](#example)
+  - [Further information](#further-information)
+    - [Contributing](#contributing)
+    - [License](#license)
+    - [Authors \& Contact](#authors--contact)
+
+---
+
+## How to install OpenHosta ?
+
+### Prerequisites
+
+1. **Python 3.8+**
+   - Download and install Python from [python.org](https://www.python.org/downloads/).
+
+2. **pip**
+   - pip is generally included with Python. Verify its installation with:
+     ```sh
+     pip --version
+     ```
+
+3. **Git**
+   - Download and install Git from [git-scm.com](https://git-scm.com/downloads).
+
+4. **Virtual Environment (optional)**
+   - Create and activate a virtual environment:
+     ```bash
+     python -m venv env
+     ```
+   - Activate the virtual environement:
+      ```bash
+      .\env\Scripts\activate # Windows
+      source env/bin/activate # macOS/Linux
+      ```
+
+5. **API Key**
+   - **API Key**: Log in to your OpenAI account from [openai.com](https://openai.com/), then create your API key. For further information, you can check this [tuto](https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key).
+
+### Installation
+
+#### Via pip
+
+1. Run the following command to install OpenHosta directly:
+ 
+```sh
+pip install openhosta
+```
+
+2. After the installation, you can verify that OpenHosta is installed correctly by running:
+
+```sh
+pip show openhosta
+```
+
+#### Via git (Developper version)
+
+1. Clone the **Git repository** to your local machine using the following command:
+
+```bash
+git clone git@github.com:hand-e-fr/OpenHosta-dev.git
+```
+
+2. Navigate to the **directory** of the cloned project:
+
+```bash
+cd OpenHosta-dev
+```
+
+3. Ensure you have installed the necessary **dependencies** before starting.
+
+```bash
+pip install -r requirements.txt
+```
+
+This way you have all the documentation and source code to understand our project
+
+### Example
+
+```python
+from openhosta import *
+
+config.set_default_apiKey("example-apikey")
+
+def my_func(a:int, b:str)->dict:
+   """
+   This Function does something.
+   """
+   return emulate()
+
+my_func(5, "Hello World!")
+
+my_lambda = thought("Do something")
+my_lambda(5)
+```
+You check OpenHosta's [documentation](doc/Docs.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](CONTRIBUTING.md) and our [Code of Conduct](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](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: MLOps, 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-1.0.1/src/OpenHosta.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/OpenHosta/__init__.py
+src/OpenHosta/analytics.py
+src/OpenHosta/config.py
+src/OpenHosta/emulate.py
+src/OpenHosta/enhancer.py
+src/OpenHosta/errors.py
+src/OpenHosta/exec.py
+src/OpenHosta/openhosta.py
+src/OpenHosta/prompt.json
+src/OpenHosta/prompt.py
+src/OpenHosta.egg-info/PKG-INFO
+src/OpenHosta.egg-info/SOURCES.txt
+src/OpenHosta.egg-info/dependency_links.txt
+src/OpenHosta.egg-info/requires.txt
+src/OpenHosta.egg-info/top_level.txt

openhosta-1.0.1/src/OpenHosta.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openhosta-1.0.1/src/OpenHosta.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests>=2.32.3
+pydantic>=2.8.2
+tiktoken>=0.7.0

openhosta-1.0.1/src/OpenHosta.egg-info/top_level.txt

@@ -0,0 +1 @@
+OpenHosta