HowdenLLM 1.6.0__tar.gz → 1.6.2__tar.gz

{howdenllm-1.6.0 → howdenllm-1.6.2}/HowdenLLM/manager.py

@@ -9,7 +9,6 @@ import os
 import json
 import re
 
-load_dotenv()
 class EmptyFileException(Exception):
     """Exception raised for empty 'filepath' argument"""
     def __init__(self, fp):
@@ -46,13 +45,13 @@ class LLM:
             if k not in ("self", "__class__", "__len__")
         }
 
-
+        load_dotenv()
         self.provider_name = provider_and_model.split(":")[0].lower()
         self.model = provider_and_model.split(":")[1]
         self.template = template
         self.name: str = name
         self.system: str = system
-        self.client = ProviderFactory.create(self.provider_name)
+        self.provider = ProviderFactory.create(self.provider_name)
         self.use_web_search_tool = use_web_search_tool
         self.hashed = self.compute_hash(self.input_params)
 
@@ -88,18 +87,18 @@ class LLM:
         input_tokens = self._count_tokens(input_text)
 
         # --- run model ---
-        output = self.client.complete(self.system, prompt, self.model, self.use_web_search_tool)
+        output = self.provider.complete(self.system, prompt, self.model, self.use_web_search_tool)
 
         # --- count output tokens ---
-        #output_tokens = self._count_tokens(output)
+        output_tokens = self._count_tokens(output)
 
         # --- update totals ---
         self.total_input_tokens += input_tokens
-        #self.total_output_tokens += output_tokens
+        self.total_output_tokens += output_tokens
         self.total_runs += 1
         print(f"[{self.name or 'LLM'}] "
               f"Input tokens: {input_tokens}, "
-              #f"Output tokens: {output_tokens}, "
+              f"Output tokens: {output_tokens}, "
               f"Total_input: {self.total_input_tokens}, "
               f"Total_output: {self.total_output_tokens}, "
               f"Total_input_average: {round(self.total_input_tokens / self.total_runs, 2)}, "

howdenllm-1.6.2/HowdenLLM/providers/known_providers.py

@@ -0,0 +1,4 @@
+class KnownProviders:
+    OpenAI = 'openai'
+    HuggingFace = 'huggingface'
+    Anthropic = 'anthropic'

{howdenllm-1.6.0 → howdenllm-1.6.2}/HowdenLLM/providers/provider_anthropic.py

@@ -1,15 +1,13 @@
 from abc import ABC
 from HowdenLLM.providers.base_provider import BaseProvider
 from anthropic import Anthropic
-import os
-from dotenv import load_dotenv
+from .known_providers import KnownProviders
 
 class AnthropicProvider(BaseProvider, ABC):
-    provider = "anthropic"
+    provider = KnownProviders.Anthropic
 
-    def __init__(self):
-        load_dotenv()
-        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+    def __init__(self,client: Anthropic):
+        self.client = client
 
     def complete(self, system: str, prompt: str, model: str, use_web_search_tool: bool) -> str:
         if model in ["claude-opus-4-6","claude-sonnet-4-6"]:

{howdenllm-1.6.0 → howdenllm-1.6.2}/HowdenLLM/providers/provider_factory.py

@@ -1,23 +1,16 @@
 import importlib
 import inspect
 import pkgutil
-
+import os
 from pathlib import Path
 from .provider_meta import ProviderMeta
-
+from dotenv import load_dotenv
+from .known_providers import KnownProviders
 
 class ProviderFactory:
     """Factory that dynamically loads provider modules and instantiates them."""
     clients_alive = {}
-    providers: dict = None
-
-    @staticmethod
-    def get_providers() -> dict:
-        if ProviderFactory.providers is None:
-            ProviderFactory._load_all_providers()
-            ProviderFactory.providers = ProviderMeta.get_registry()
-
-        return ProviderFactory.providers
+    openai_client = None
 
     @staticmethod
     def _load_all_providers():
@@ -34,9 +27,9 @@ class ProviderFactory:
     @staticmethod
     def create(provider_name: str):
         """Instantiate a provider by name using the registry."""
-        #ProviderFactory._load_all_providers()
-        providers = ProviderFactory.get_providers()
+        ProviderFactory._load_all_providers()
 
+        providers = ProviderMeta.get_registry()
         key = provider_name.lower()
 
         if key not in providers:
@@ -46,7 +39,15 @@ class ProviderFactory:
             )
 
         if key not in ProviderFactory.clients_alive.keys():
-            ProviderFactory.clients_alive[key] = providers[key]()
-
-        return ProviderFactory.clients_alive[key]
-
+            load_dotenv()
+            if key == KnownProviders.OpenAI:
+                from openai import OpenAI
+                ProviderFactory.clients_alive[key] = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            elif key == KnownProviders.HuggingFace:
+                from huggingface_hub import InferenceClient
+                ProviderFactory.clients_alive[key] = InferenceClient(token=os.getenv("HUGGINGFACE_API_KEY"))
+            elif key == KnownProviders.Anthropic:
+                from anthropic import Anthropic
+                ProviderFactory.clients_alive[key] = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+        return providers[key](ProviderFactory.clients_alive[key])

{howdenllm-1.6.0 → howdenllm-1.6.2}/HowdenLLM/providers/provider_huggingface.py

@@ -2,15 +2,14 @@ from HowdenLLM.providers.base_provider import BaseProvider
 from dotenv import load_dotenv
 import os
 from huggingface_hub import InferenceClient
-
+from .known_providers import KnownProviders
 
 
 class HuggingFaceProvider(BaseProvider):
-    provider = 'huggingface'
+    provider = KnownProviders.HuggingFace
 
-    def __init__(self):
-        load_dotenv()
-        self.client = InferenceClient(token=os.getenv("HUGGINGFACE_API_KEY"))
+    def __init__(self,client: InferenceClient):
+        self.client = client
 
     def complete(self, system: str, prompt: str, model: str, use_web_search_tool: bool) -> str:
         full_prompt = f"[System]: {system}\n[User]: {prompt}\n"

howdenllm-1.6.2/HowdenLLM/providers/provider_openai.py

@@ -0,0 +1,34 @@
+from abc import ABC
+from HowdenLLM.providers.base_provider import BaseProvider
+from openai import OpenAI
+from .known_providers import KnownProviders
+
+class OpenAIProvider(BaseProvider, ABC):
+    provider = KnownProviders.OpenAI
+
+    def __init__(self,client: OpenAI):
+        self.client = client
+
+    def complete(self, system: str, prompt: str, model: str, use_web_search_tool: bool) -> str:
+
+        if use_web_search_tool:
+            tools = [
+                { "type": "web_search" }
+            ]
+        else:
+            tools = None
+
+        if model in ["gpt-5", "gpt-5.2", "gpt-5-mini", "gpt-5.4-mini", "gpt-5-nano"]:
+            response = self.client.responses.create(
+                model=model,
+                input=[
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": prompt}
+                ],
+                tools=tools,
+                max_output_tokens=16000
+            )
+        else:
+            raise Exception(f"Unsupported model: {model}")
+
+        return response.output_text

{howdenllm-1.6.0 → howdenllm-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HowdenLLM
-Version: 1.6.0
+Version: 1.6.2
 Summary: A simple configuration manager with Pydantic and JSON export.
 License: MIT
 Keywords: config,configuration,pydantic,json

{howdenllm-1.6.0 → howdenllm-1.6.2}/pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "HowdenLLM"
-version = "1.6.0"
+version = "1.6.2"
 description = "A simple configuration manager with Pydantic and JSON export."
 authors = [ "JesperThoftIllemannJ <jesper.jaeger@howdendanmark.dk>",]
 readme = "README.md"

howdenllm-1.6.0/HowdenLLM/providers/known_providers.py

@@ -1,2 +0,0 @@
-class KnownProviders:
-    Anthropic = 'anthropic'

howdenllm-1.6.0/HowdenLLM/providers/provider_openai.py

@@ -1,40 +0,0 @@
-from abc import ABC
-from HowdenLLM.providers.base_provider import BaseProvider
-from openai import OpenAI, AsyncOpenAI
-import os
-from dotenv import load_dotenv
-import asyncio
-
-
-SEMAPHORE = asyncio.Semaphore(3)
-
-class OpenAIProvider(BaseProvider, ABC):
-    provider = "openai"
-
-    def __init__(self):
-        load_dotenv()
-        self.client =  AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
-    async def complete(self, system: str, prompt: str, model: str, use_web_search_tool: bool) -> str:
-        async with SEMAPHORE:
-            if use_web_search_tool:
-                tools = [
-                    { "type": "web_search" }
-                ]
-            else:
-                tools = None
-
-            if model in ["gpt-5", "gpt-5-mini", "gpt-5-nano"]:
-                response = await self.client.responses.create(
-                    model=model,
-                    input=[
-                        {"role": "system", "content": system},
-                        {"role": "user", "content": prompt}
-                    ],
-                    tools=tools,
-                    max_output_tokens=16000
-                )
-            else:
-                raise Exception(f"Unsupported model: {model}")
-
-            return response.output_text