sunholo 0.71.29__py3-none-any.whl → 0.73.2__py3-none-any.whl

sunholo/agents/dispatch_to_qa.py

@@ -12,7 +12,7 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 from ..logging import log
-from ..utils import load_config_key
+from ..utils import ConfigManager
 from ..auth import get_header
 import requests
 import aiohttp
@@ -46,26 +46,29 @@ def prep_request_payload(user_input, chat_history, vector_name, stream, **kwargs
     ```
     """
 
+    config = ConfigManager(vector_name)
+
     # Add chat_history/vector_name to kwargs so langserve can use them too
     kwargs['chat_history'] = chat_history
 
-    agent = load_config_key("agent", vector_name=vector_name, kind="vacConfig")
-    agent_type = load_config_key("agent_type", vector_name=vector_name, kind="vacConfig")
+    agent = config.vacConfig("agent")
+    agent_type = config.vacConfig("agent_type")
 
     override_endpoint = kwargs.get("override_endpoint")
     if override_endpoint:
         log.info(f"Overriding endpoint with {override_endpoint}")
 
     # {'stream': '', 'invoke': ''}
-    endpoints = route_endpoint(vector_name, override_endpoint=override_endpoint)
+    post_endpoints = route_endpoint(override_endpoint=override_endpoint, config=config)
 
     if stream:
-        qna_endpoint = endpoints["stream"]
+        qna_endpoint = post_endpoints["stream"]
     else: 
-        qna_endpoint = endpoints["invoke"]
+        qna_endpoint = post_endpoints["invoke"]
 
     if agent == "langserve" or agent_type == "langserve":
-        qna_data = prepare_request_data(user_input, endpoints["input_schema"], vector_name, **kwargs)
+        get_endpoints = route_endpoint(override_endpoint=override_endpoint, method = 'get', config=config)
+        qna_data = prepare_request_data(user_input, get_endpoints["input_schema"], vector_name, **kwargs)
     else:
         # Base qna_data dictionary
         qna_data = {

sunholo/agents/langserve.py

@@ -97,6 +97,6 @@ def prepare_request_data(user_input, endpoint, vector_name, **kwargs):
 
         return request_data
     else:
-        log.error("Invalid or no input schema available.")
+        log.error(f"Invalid or no input schema available for {endpoint=} {input_schema=}")
         return None
 

sunholo/agents/route.py

@@ -12,18 +12,24 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 from ..logging import log
-from ..utils import load_config_key, load_config
+from ..utils import load_config, ConfigManager
 
-def route_vac(vector_name: str) -> str :
+def route_vac(vector_name: str=None, config=None) -> str :
     """
     Considers what VAC this vector_name belongs to
     """
-    agent_url = load_config_key('agent_url', vector_name=vector_name, kind="vacConfig")
+    if not vector_name and not config:
+        raise ValueError("Must provide config or vector_name argument")
+    
+    if not config:
+        config = ConfigManager(vector_name)
+
+    agent_url = config.vacConfig('agent_url')
     if agent_url:
         log.info('agent_url found in llm_config.yaml')
         return agent_url
 
-    agent = load_config_key('agent', vector_name, kind="vacConfig")
+    agent = config.vacConfig('agent')
     log.info(f'agent_type: {agent}')
 
     agent_route, _ = load_config('config/cloud_run_urls.json')
@@ -37,15 +43,24 @@ def route_vac(vector_name: str) -> str :
     log.info(f'agent_url: {agent_url}')
     return agent_url
 
-def route_endpoint(vector_name, method = 'post', override_endpoint=None):
+def route_endpoint(vector_name=None, method = 'post', override_endpoint=None, config=None):
+
+    if vector_name is None and config is None:
+        raise ValueError('vector_name and config can not both be None')
+    
+    if config:
+        vector_name = config.vector_name
+
+    if not config:
+        config = ConfigManager(vector_name)
 
-    agent_type = load_config_key('agent_type', vector_name, kind="vacConfig")
+    agent_type = config.vacConfig('agent_type')
     if not agent_type:
-        agent_type = load_config_key('agent', vector_name, kind="vacConfig")
+        agent_type = config.vacConfig('agent')
 
-    stem = route_vac(vector_name) if not override_endpoint else override_endpoint
+    stem = route_vac(config=config) if not override_endpoint else override_endpoint
     
-    agents_config = load_config_key(agent_type, vector_name, kind="agentConfig")
+    agents_config = config.agentConfig(agent_type)
     
     log.info(f"agents_config: {agents_config}")
     if method not in agents_config:

sunholo/cli/chat_vac.py

@@ -1,19 +1,19 @@
 from ..agents import send_to_qa, handle_special_commands
 from ..streaming import generate_proxy_stream, can_agent_stream
 from ..utils.user_ids import generate_user_id
-from ..utils.config import load_config_key
+from ..utils import ConfigManager
 from ..utils.api_key import has_multivac_api_key
 from ..logging import log
 from ..qna.parsers import parse_output
 from ..gcs.add_file import add_file_to_gcs
 from .run_proxy import clean_proxy_list, start_proxy, stop_proxy
+from ..invoke import invoke_vac
 
 import uuid
 import os
 import sys
 import subprocess
 import json
-import requests
 from pathlib import Path
 
 from rich import print
@@ -30,7 +30,7 @@ def get_service_url(vac_name, project, region, no_config=False):
     if no_config:
         agent_name = vac_name
     else:
-        agent_name = load_config_key("agent", vac_name, kind="vacConfig")
+        agent_name = ConfigManager(vac_name).vacConfig("agent")
 
     proxies = clean_proxy_list()
     if agent_name in proxies:
@@ -50,7 +50,7 @@ def handle_file_upload(file, vector_name):
     if not Path(file).is_file():
         return None
     
-    agent_name = load_config_key("agent", vector_name, kind="vacConfig")
+    agent_name = ConfigManager(vector_name).vacConfig("agent")
     # vertex can't handle directories
     bucket_filepath = f"{vector_name}/uploads/{os.path.basename(file)}" if agent_name != "vertex-genai" else os.path.basename(file)
 
@@ -65,7 +65,8 @@ def stream_chat_session(service_url, service_name, stream=True):
 
     user_id = generate_user_id()
     chat_history = []
-    agent_name = load_config_key("agent", service_name, kind="vacConfig")
+    agent_name = ConfigManager(service_name).vacConfig("agent")
+    file_reply = None
     while True:
         session_id = str(uuid.uuid4())
         user_input = Prompt.ask("[bold cyan]You[/bold cyan]")
@@ -274,15 +275,19 @@ def resolve_service_url(args, no_config=False):
 
         return args.url_override
     
-    agent_name = load_config_key("agent", args.vac_name, kind="vacConfig")
-    agent_url = load_config_key("agent_url", args.vac_name, "vacConfig")
+    config = ConfigManager(args.vac_name)
+    global_config = ConfigManager("global")
+
+    agent_name = config.vacConfig("agent")
+    agent_url = config.vacConfig("agent_url")
+
     if agent_url:
         console.print("Found agent_url within vacConfig: {agent_url}")
     
     # via public cloud endpoints - assumes no gcloud auth
     if has_multivac_api_key():
         log.debug("Found MULTIVAC_API_KEY")
-        gcp_config = load_config_key("gcp_config", "global", "vacConfig")
+        gcp_config = global_config.vacConfig("gcp_config")
         endpoints_base_url = gcp_config.get("endpoints_base_url")
         if not endpoints_base_url:
             console.print("[bold red]MULTIVAC_API_KEY env var is set but no config.gcp_config.endpoints_base_url can be found[/bold red]")
@@ -310,6 +315,8 @@ def resolve_service_url(args, no_config=False):
 
 def vac_command(args):
 
+    config = ConfigManager(args.vac_name)
+
     if args.action == 'list':
 
         list_cloud_run_services(args.project, args.region)
@@ -324,7 +331,7 @@ def vac_command(args):
     
     elif args.action == 'chat':
         service_url = resolve_service_url(args)
-        agent_name   = load_config_key("agent", args.vac_name, kind="vacConfig")
+        agent_name   = config.vacConfig("agent")
 
         streamer = can_agent_stream(agent_name)
         log.debug(f"streamer: {streamer}")
@@ -334,9 +341,10 @@ def vac_command(args):
         if args.headless:
             headless_mode(service_url, args.vac_name, args.user_input, args.chat_history, stream=streamer)
         else:
-            display_name = load_config_key("display_name", vector_name=args.vac_name,  kind="vacConfig")
-            description  = load_config_key("description", vector_name=args.vac_name, kind="vacConfig")
-            endpoints_config = load_config_key(agent_name, "dummy_value", kind="agentConfig")
+            display_name = config.vacConfig("display_name")
+            description  = config.vacConfig("description")
+            endpoints_config = config.agentConfig(agent_name)
+
             post_endpoints = endpoints_config['post']
 
             display_endpoints = ' '.join(f"{key}: {value}" for key, value in post_endpoints.items())
@@ -362,54 +370,6 @@ def vac_command(args):
 
         invoke_vac(service_url, args.data, is_file=args.is_file)
 
-def invoke_vac(service_url, data, vector_name=None, metadata=None, is_file=False):
-    try:
-        if is_file:
-            console.print("Uploading file...")
-            # Handle file upload
-            if not isinstance(data, Path) or not data.is_file():
-                raise ValueError("For file uploads, 'data' must be a Path object pointing to a valid file.")
-            
-            files = {
-                'file': (data.name, open(data, 'rb')),
-            }
-            form_data = {
-                'vector_name': vector_name,
-                'metadata': json.dumps(metadata) if metadata else '',
-            }
-
-            response = requests.post(service_url, files=files, data=form_data)
-        else:
-            console.print("Uploading JSON...")
-            try:
-                if isinstance(data, dict):
-                    json_data = data
-                else:
-                    json_data = json.loads(data)
-            except json.JSONDecodeError as err:
-                console.print(f"[bold red]ERROR: invalid JSON: {str(err)} [/bold red]")
-                sys.exit(1)
-            except Exception as err:
-                console.print(f"[bold red]ERROR: could not parse JSON: {str(err)} [/bold red]")
-                sys.exit(1)
-
-            log.debug(f"Sending data: {data} or json_data: {json.dumps(json_data)}")
-            # Handle JSON data
-            headers = {"Content-Type": "application/json"}
-            response = requests.post(service_url, headers=headers, data=json.dumps(json_data))
-
-        response.raise_for_status()
-
-        the_data = response.json()
-        console.print(the_data)
-
-        return the_data
-    
-    except requests.exceptions.RequestException as e:
-        console.print(f"[bold red]ERROR: Failed to invoke VAC: {e}[/bold red]")
-    except Exception as e:
-        console.print(f"[bold red]ERROR: An unexpected error occurred: {e}[/bold red]")
-
 
 def list_cloud_run_services(project, region):
     """

sunholo/cli/cli.py

@@ -10,7 +10,7 @@ from .chat_vac import setup_vac_subparser
 from .embedder import setup_embedder_subparser
 from .swagger import setup_swagger_subparser
 
-from ..utils.config import load_config_key
+from ..utils import ConfigManager
 
 from ..logging import log
 
@@ -20,9 +20,9 @@ from rich.panel import Panel
 
 def load_default_gcp_config():
     try:
-        gcp_config = load_config_key('gcp_config', 'global', kind="vacConfig")
+        gcp_config = ConfigManager("global").vacConfig("gcp_config")
     except FileNotFoundError as e:
-        console.print(f"{e} - move config/ folder to working directory or set the _CONFIG_FOLDER environment variable to its location")
+        console.print(f"{e} - move config/ folder to working directory or set the VAC_CONFIG_FOLDER environment variable to its location")
         sys.exit(1)
 
     if gcp_config:

sunholo/cli/embedder.py

@@ -8,7 +8,8 @@ from pathlib import Path
 from .sun_rich import console
 from rich.progress import Progress
 
-from .chat_vac import resolve_service_url, invoke_vac
+from ..invoke import invoke_vac
+from .chat_vac import resolve_service_url
 from .run_proxy import stop_proxy
 
 def create_metadata(vac, metadata):

sunholo/components/retriever.py

@@ -13,7 +13,7 @@
 #   limitations under the License.
 from ..logging import log
 from .vectorstore import pick_vectorstore
-from ..utils import load_config_key
+from ..utils import load_config_key, ConfigManager
 from .llm import get_embeddings
 from ..utils.gcp_project import get_gcp_project
 
@@ -27,7 +27,7 @@ from langchain.retrievers import ContextualCompressionRetriever
 
 
 def load_memories(vector_name):
-    memories = load_config_key("memory", vector_name, kind="vacConfig")
+    memories = ConfigManager(vector_name).vacConfig("memory")
     log.info(f"Found memory settings for {vector_name}: {memories}")
     if not memories or len(memories) == 0:
         log.info(f"No memory settings found for {vector_name}")

sunholo/gcs/add_file.py

@@ -22,7 +22,7 @@ except ImportError:
     storage = None
 
 from ..logging import log
-from ..utils.config import load_config_key
+from ..utils import load_config_key, ConfigManager
 
 
 def handle_base64_image(base64_data: str, vector_name: str, extension: str):
@@ -37,7 +37,8 @@ def handle_base64_image(base64_data: str, vector_name: str, extension: str):
     Returns:
         Tuple[str, str]: The URI of the uploaded image and the MIME type.
     """
-    model = load_config_key("llm", vector_name, "vacConfig")
+    
+    model = ConfigManager(vector_name).vacConfig("llm")
     if model.startswith("openai"):  # pass it to gpt directly
         return base64_data, base64_data.split(",", 1)
 
@@ -69,16 +70,19 @@ def handle_base64_image(base64_data: str, vector_name: str, extension: str):
 
 def resolve_bucket(vector_name):
     if os.getenv('EXTENSIONS_BUCKET'):
+        log.warning('Resolving to EXTENSIONS_BUCKET environment variable')
         return os.getenv('EXTENSIONS_BUCKET')
     
-    bucket_config = load_config_key("upload", vector_name, "vacConfig")
-    if bucket_config:
-        if bucket_config.get("buckets"):
-            bucket_name = bucket_config.get("buckets").get("all")
-    else:
-        bucket_name = os.getenv('GCS_BUCKET')
-        if not bucket_name:
-            raise ValueError("No bucket found to upload to: GCS_BUCKET returned None")
+    if vector_name:
+        bucket_config = ConfigManager(vector_name).vacConfig("upload")
+
+        if bucket_config:
+            if bucket_config.get("buckets"):
+                bucket_name = bucket_config.get("buckets").get("all")
+
+    bucket_name = bucket_name or os.getenv('GCS_BUCKET')
+    if not bucket_name:
+        raise ValueError("No bucket found to upload to: GCS_BUCKET returned None")
     
     if bucket_name.startswith("gs://"):
         bucket_name = bucket_name.removeprefix("gs://")
@@ -86,7 +90,7 @@ def resolve_bucket(vector_name):
     return bucket_name
 
 def add_file_to_gcs(filename: str, 
-                    vector_name:str, 
+                    vector_name:str=None, 
                     bucket_name: str=None, 
                     metadata:dict=None, 
                     bucket_filepath:str=None):
@@ -114,7 +118,11 @@ def add_file_to_gcs(filename: str,
     if os.getenv('EXTENSIONS_BUCKET'):
         bucket_filepath = os.path.basename(filename)
 
+    if vector_name is None:
+            vector_name = "global"
+    
     if not bucket_filepath:
+        
         bucket_filepath = f"{vector_name}/{year}/{month}/{day}/{hour}/{os.path.basename(filename)}"
     bucket_filepath_prev = f"{vector_name}/{year}/{month}/{day}/{hour_prev}/{os.path.basename(filename)}"
 

sunholo/invoke/__init__.py

@@ -0,0 +1 @@
+from .invoke_vac_utils import invoke_vac, invoke_vac_qa

sunholo/invoke/invoke_vac_utils.py

@@ -0,0 +1,151 @@
+import json
+import requests
+
+from pathlib import Path
+
+from ..logging import log
+from ..agents import send_to_qa
+from ..qna.parsers import parse_output
+from ..streaming import generate_proxy_stream
+
+def invoke_vac_qa(vac_input: dict, vac_name: str, chat_history=[], stream=False):
+    """
+    This lets VACs call other VAC Q&A endpoints within their code
+    """
+
+    if 'user_input' not in vac_input:
+        raise ValueError('vac_input must contain at least "user_input" key - got {vac_input}')
+
+    user_id = vac_input.get('user_id')
+    session_id = vac_input.get('session_id')
+    image_uri = vac_input.get('image_url') or vac_input.get('image_uri')
+
+    if not stream:
+        log.info(f'Batch invoke_vac_qa with {vac_input=}')
+        vac_response = send_to_qa(
+            vac_input["user_input"],
+            vector_name=vac_name,
+            chat_history=chat_history,
+            message_author=user_id,
+            #TODO: populate these
+            image_url=image_uri,
+            source_filters=None,
+            search_kwargs=None,
+            private_docs=None,
+            whole_document=False,
+            source_filters_and_or=False,
+            # system kwargs
+            configurable={
+                "vector_name": vac_name,
+            },
+            user_id=user_id,
+            session_id=session_id, 
+            message_source="sunholo.invoke_vac_qa.invoke")
+        
+        # ensures {'answer': answer}
+        answer = parse_output(vac_response)
+        chat_history.append({"name": "Human", "content": vac_input})
+        chat_history.append({"name": "AI", "content": answer})
+        answer["chat_history"] = chat_history
+        
+        return answer
+    
+    log.info(f"Streaming invoke_vac_qa with {vac_input=}")
+    def stream_response():
+        generate = generate_proxy_stream(
+                send_to_qa,
+                vac_input["user_input"],
+                vector_name=vac_name,
+                chat_history=chat_history,
+                generate_f_output=lambda x: x,  # Replace with actual processing function
+                stream_wait_time=0.5,
+                stream_timeout=120,
+                message_author=user_id,
+                #TODO: populate these
+                image_url=image_uri,
+                source_filters=None,
+                search_kwargs=None,
+                private_docs=None,
+                whole_document=False,
+                source_filters_and_or=False,
+                # system kwargs
+                configurable={
+                    "vector_name": vac_name,
+                },
+                user_id=user_id,
+                session_id=session_id, 
+                message_source="sunholo.invoke_vac_qa.stream"
+        )
+        for part in generate():
+            yield part
+
+    answer = ""
+
+    for token in stream_response():
+        if isinstance(token, bytes):
+            token = token.decode('utf-8')
+            yield token
+        if isinstance(token, dict):
+            # ?
+            pass
+        elif isinstance(token, str):
+            answer += token
+
+    if answer:
+        chat_history.append({"name": "Human", "content": vac_input})
+        chat_history.append({"name": "AI", "content": answer})
+
+    return chat_history
+
+def invoke_vac(service_url, data, vector_name=None, metadata=None, is_file=False):
+    """
+    This lets a VAC be invoked by directly calling its URL, used for file uploads
+    """
+    try:
+        if is_file:
+            log.info("Uploading file...")
+            # Handle file upload
+            if not isinstance(data, Path) or not data.is_file():
+                raise ValueError("For file uploads, 'data' must be a Path object pointing to a valid file.")
+            
+            files = {
+                'file': (data.name, open(data, 'rb')),
+            }
+            form_data = {
+                'vector_name': vector_name,
+                'metadata': json.dumps(metadata) if metadata else '',
+            }
+
+            response = requests.post(service_url, files=files, data=form_data)
+        else:
+            log.info("Uploading JSON...")
+            try:
+                if isinstance(data, dict):
+                    json_data = data
+                else:
+                    json_data = json.loads(data)
+            except json.JSONDecodeError as err:
+                log.error(f"[bold red]ERROR: invalid JSON: {str(err)} [/bold red]")
+                raise err
+            except Exception as err:
+                log.error(f"[bold red]ERROR: could not parse JSON: {str(err)} [/bold red]")
+                raise err
+
+            log.debug(f"Sending data: {data} or json_data: {json.dumps(json_data)}")
+            # Handle JSON data
+            headers = {"Content-Type": "application/json"}
+            response = requests.post(service_url, headers=headers, data=json.dumps(json_data))
+
+        response.raise_for_status()
+
+        the_data = response.json()
+        log.info(the_data)
+
+        return the_data
+    
+    except requests.exceptions.RequestException as e:
+        log.error(f"[bold red]ERROR: Failed to invoke VAC: {e}[/bold red]")
+        raise e
+    except Exception as e:
+        log.error(f"[bold red]ERROR: An unexpected error occurred: {e}[/bold red]")
+        raise e

sunholo/langfuse/prompts.py

@@ -1,8 +1,8 @@
 from ..logging import log
-from ..utils import load_config_key
+from ..utils import ConfigManager
 
 # Load the YAML file
-def load_prompt_from_yaml(key, prefix="sunholo", file_path=None):
+def load_prompt_from_yaml(key, prefix="sunholo", load_from_file=False):
     """
     Returns a string you can use with Langfuse PromptTemplate.from_template() 
 
@@ -17,6 +17,12 @@ def load_prompt_from_yaml(key, prefix="sunholo", file_path=None):
     from langchain_core.prompts import PromptTemplate
     
     """
+    config = ConfigManager(prefix)
+    if load_from_file:
+        
+        return config.promptConfig(key)
+
+
     from langfuse import Langfuse
 
     # Initialize Langfuse client
@@ -35,4 +41,4 @@ def load_prompt_from_yaml(key, prefix="sunholo", file_path=None):
     except Exception as err:
         log.warning(f"Could not find langfuse template: {langfuse_template} - {str(err)} - attempting to load from promptConfig")
 
-    return load_config_key(key, vector_name=prefix, kind="promptConfig")
+    return config.promptConfig(key)

sunholo/llamaindex/import_files.py

@@ -4,7 +4,7 @@ except ImportError:
     rag = None
 
 from ..logging import log
-from ..utils.config import load_config_key
+from ..utils import ConfigManager
 from ..vertex import init_vertex
 from .get_files import fetch_corpus
 from ..components import load_memories
@@ -41,7 +41,8 @@ def do_llamaindex(message_data, metadata, vector_name):
     if not rag:
         raise ValueError("Need to install vertexai module via `pip install sunholo[gcp]`")
 
-    gcp_config = load_config_key("gcp_config", vector_name=vector_name, kind="vacConfig")
+    config = ConfigManager(vector_name)
+    gcp_config = config.vacConfig("gcp_config")
     if not gcp_config:
         raise ValueError(f"Need config.{vector_name}.gcp_config to configure llamaindex on VertexAI")
 
@@ -81,7 +82,7 @@ def do_llamaindex(message_data, metadata, vector_name):
                 
                 corpuses.append(corpus)
     if not corpuses:
-        log.warning("Could not find a Vertex Llamaindex RAG corpus to import data to despite being in config")
+        log.info("No Vertex Llamaindex RAG corpus to import data")
         return None
     
     try:
@@ -93,8 +94,7 @@ def do_llamaindex(message_data, metadata, vector_name):
     log.info(f"Found llamaindex corpus: {corpuses}")
 
     # native support for cloud storage and drive links
-    chunker_config = load_config_key("chunker", vector_name=vector_name, kind="vacConfig")
-
+    chunker_config = config.vacConfig("chunker")
     
     if message_data.startswith("gs://") or message_data.startswith("https://drive.google.com"):
         log.info(f"rag.import_files for {message_data}")
@@ -115,7 +115,8 @@ def do_llamaindex(message_data, metadata, vector_name):
         
 
 def check_llamaindex_in_memory(vector_name):
-    memories = load_config_key("memory", vector_name=vector_name, kind="vacConfig")
+    memories = ConfigManager(vector_name).vacConfig("memory")
+
     for memory in memories:  # Iterate over the list
         for key, value in memory.items():  # Now iterate over the dictionary
             log.info(f"Found memory {key}")
@@ -130,7 +131,7 @@ def check_llamaindex_in_memory(vector_name):
 
 def llamaindex_chunker_check(message_data, metadata, vector_name):
     # llamaindex handles its own chunking/embedding
-    memories = load_config_key("memory", vector_name=vector_name, kind="vacConfig")
+    memories = ConfigManager(vector_name).vacConfig("memory")
     total_memories = len(memories)
     llama = None
     if check_llamaindex_in_memory(vector_name):

sunholo/streaming/langserve.py

@@ -158,11 +158,14 @@ def parse_json_data(json_data: dict):
     try:
         if isinstance(json_data, dict):
             content = json_data.get('content', None)
+            metadata = json_data.get('metadata', None)
             if content is not None: # content can be '' empty string
                 #log.debug(f'Yield content: {content}')
                 yield content
+            elif metadata is not None:
+                log.debug('Metadata:', metadata)
             else:
-                log.debug(f'No "content" key found, yielding all json data dict: {json_data}')
+                log.debug(f'No "content" or "metadata" key found, yielding all json data dict: {json_data}')
                 yield json_data # Yielding all JSON data
         elif isinstance(json_data, str):
             yield json_data

sunholo/utils/__init__.py

@@ -1 +1,2 @@
-from .config import load_config_key, load_config
+from .config import load_config_key, load_config
+from .config_class import ConfigManager

sunholo/utils/config.py

@@ -57,7 +57,7 @@ def load_all_configs():
     """
     from ..logging import log
 
-    if not os.getenv("_CONFIG_FOLDER", None):
+    if not os.getenv("_CONFIG_FOLDER"):
         log.debug("_CONFIG_FOLDER is not set, using os.getcwd() instead")
     else:
         log.debug(f"_CONFIG_FOLDER set to: {os.getenv('_CONFIG_FOLDER')}")