osbot-utils 1.81.0__py3-none-any.whl → 1.83.0__py3-none-any.whl

osbot_utils/base_classes/Type_Safe.py

@@ -1,31 +1,14 @@
 # todo: find a way to add these documentations strings to a separate location so that
-#       the code is not polluted with them (like in the example below)
 #       the data is available in IDE's code complete
-import functools
-import inspect
+
 import sys
 import types
-import typing
-from decimal                                    import Decimal
-from enum                                       import Enum, EnumMeta
-from typing                                     import List
-from osbot_utils.base_classes.Type_Safe__List   import Type_Safe__List
-from osbot_utils.helpers.Random_Guid            import Random_Guid
-from osbot_utils.helpers.Random_Guid_Short      import Random_Guid_Short
-from osbot_utils.helpers.Safe_Id                import Safe_Id
-from osbot_utils.helpers.Timestamp_Now          import Timestamp_Now
-from osbot_utils.utils.Dev                      import pprint
-from osbot_utils.utils.Json                     import json_parse, json_to_bytes, json_to_gz
-from osbot_utils.utils.Misc                     import list_set
-from osbot_utils.utils.Objects                  import default_value, value_type_matches_obj_annotation_for_attr, \
-    raise_exception_on_obj_type_annotation_mismatch, obj_is_attribute_annotation_of_type, enum_from_value, \
-    obj_is_type_union_compatible, value_type_matches_obj_annotation_for_union_attr, \
-    convert_dict_to_value_from_obj_annotation, dict_to_obj, convert_to_value_from_obj_annotation, \
-    obj_attribute_annotation
+from osbot_utils.utils.Objects import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):                                           # pragma: no cover
     def get_origin(tp):
+        import typing
         if isinstance(tp, typing._GenericAlias):
             return tp.__origin__
         elif tp is typing.Generic:
@@ -34,6 +17,7 @@ if sys.version_info < (3, 8):                                           # pragma
             return None
 
     def get_args(tp):
+        import typing
         if isinstance(tp, typing._GenericAlias):
             return tp.__args__
         else:
@@ -46,7 +30,7 @@ if sys.version_info >= (3, 10):
 else:                                                           # pragma: no cover
     NoneType = type(None)
 
-immutable_types = (bool, int, float, complex, str, tuple, frozenset, bytes, NoneType, EnumMeta)
+
 
 
 #todo: see if we can also add type safety to method execution
@@ -56,9 +40,11 @@ immutable_types = (bool, int, float, complex, str, tuple, frozenset, bytes, None
 class Type_Safe:
 
     def __init__(self, **kwargs):
+        from osbot_utils.utils.Objects import raise_exception_on_obj_type_annotation_mismatch
 
         for (key, value) in self.__cls_kwargs__().items():                  # assign all default values to self
             if value is not None:                                           # when the value is explicitly set to None on the class static vars, we can't check for type safety
+
                 raise_exception_on_obj_type_annotation_mismatch(self, key, value)
             if hasattr(self, key):
                 existing_value = getattr(self, key)
@@ -79,6 +65,11 @@ class Type_Safe:
     def __exit__(self, exc_type, exc_val, exc_tb): pass
 
     def __setattr__(self, name, value):
+        from osbot_utils.utils.Objects import convert_dict_to_value_from_obj_annotation
+        from osbot_utils.utils.Objects import convert_to_value_from_obj_annotation
+        from osbot_utils.utils.Objects import value_type_matches_obj_annotation_for_attr
+        from osbot_utils.utils.Objects import value_type_matches_obj_annotation_for_union_attr
+
         if not hasattr(self, '__annotations__'):                    # can't do type safety checks if the class does not have annotations
             return super().__setattr__(name, value)
 
@@ -101,11 +92,20 @@ class Type_Safe:
         super().__setattr__(name, value)
 
     def __attr_names__(self):
+        from osbot_utils.utils.Misc import list_set
+
         return list_set(self.__locals__())
 
     @classmethod
-    def __cls_kwargs__(cls, include_base_classes=True):
-        """Return current class dictionary of class level variables and their values."""
+    def __cls_kwargs__(cls, include_base_classes=True):                  # Return current class dictionary of class level variables and their values
+        import functools
+        import inspect
+        from enum                      import EnumMeta
+        from osbot_utils.utils.Objects import obj_is_type_union_compatible
+
+        IMMUTABLE_TYPES = (bool, int, float, complex, str, tuple, frozenset, bytes, NoneType, EnumMeta)
+
+
         kwargs = {}
 
         for base_cls in inspect.getmro(cls):
@@ -134,11 +134,11 @@ class Type_Safe:
                             if var_type and not isinstance(var_value, var_type):                                    # check type
                                 exception_message = f"variable '{var_name}' is defined as type '{var_type}' but has value '{var_value}' of type '{type(var_value)}'"
                                 raise ValueError(exception_message)
-                            if var_type not in immutable_types and var_name.startswith('__') is False:              # if var_type is not one of the immutable_types or is an __ internal
+                            if var_type not in IMMUTABLE_TYPES and var_name.startswith('__') is False:              # if var_type is not one of the IMMUTABLE_TYPES or is an __ internal
                                 #todo: fix type safety bug that I believe is caused here
-                                if obj_is_type_union_compatible(var_type, immutable_types) is False:                # if var_type is not something like Optional[Union[int, str]]
-                                    if type(var_type) not in immutable_types:
-                                        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Kwargs_To_Self, with only the following immutable types being supported: '{immutable_types}'"
+                                if obj_is_type_union_compatible(var_type, IMMUTABLE_TYPES) is False:                # if var_type is not something like Optional[Union[int, str]]
+                                    if type(var_type) not in IMMUTABLE_TYPES:
+                                        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Kwargs_To_Self, with only the following immutable types being supported: '{IMMUTABLE_TYPES}'"
                                         raise ValueError(exception_message)
             if include_base_classes is False:
                 break
@@ -146,6 +146,9 @@ class Type_Safe:
 
     @classmethod
     def __default__value__(cls, var_type):
+        import typing
+        from osbot_utils.base_classes.Type_Safe__List import Type_Safe__List
+
         if var_type is typing.Set:                              # todo: refactor the dict, set and list logic, since they are 90% the same
             return set()
         if get_origin(var_type) is set:
@@ -164,8 +167,8 @@ class Type_Safe:
         else:
             return default_value(var_type)                      # for all other cases call default_value, which will try to create a default instance
 
-    def __default_kwargs__(self):
-        """Return entire (including base classes) dictionary of class level variables and their values."""
+    def __default_kwargs__(self):                               # Return entire (including base classes) dictionary of class level variables and their values.
+        import inspect
         kwargs = {}
         cls = type(self)
         for base_cls in inspect.getmro(cls):                  # Traverse the inheritance hierarchy and collect class-level attributes
@@ -217,9 +220,13 @@ class Type_Safe:
     # todo: see if there should be a prefix on these methods, to make it easier to spot them
     #       of if these are actually that useful that they should be added like this
     def bytes(self):
+        from osbot_utils.utils.Json import json_to_bytes
+
         return json_to_bytes(self.json())
 
     def bytes_gz(self):
+        from osbot_utils.utils.Json import json_to_gz
+
         return json_to_gz(self.json())
 
     def json(self):
@@ -240,8 +247,8 @@ class Type_Safe:
         for k,v in self.__cls_kwargs__().items():
             setattr(self, k, v)
 
-    def update_from_kwargs(self, **kwargs):
-        """Update instance attributes with values from provided keyword arguments."""
+    def update_from_kwargs(self, **kwargs):                         # Update instance attributes with values from provided keyword arguments.
+        from osbot_utils.utils.Objects import value_type_matches_obj_annotation_for_attr
         for key, value in kwargs.items():
             if value is not None:
                 if hasattr(self,'__annotations__'):  # can only do type safety checks if the class does not have annotations
@@ -278,6 +285,16 @@ class Type_Safe:
 
     # todo: this needs refactoring, since the logic and code is getting quite complex (to be inside methods like this)
     def deserialize_from_dict(self, data, raise_on_not_found=False):
+        from decimal                                    import Decimal
+        from enum                                       import EnumMeta
+        from osbot_utils.base_classes.Type_Safe__List   import Type_Safe__List
+        from osbot_utils.helpers.Random_Guid            import Random_Guid
+        from osbot_utils.helpers.Random_Guid_Short      import Random_Guid_Short
+        from osbot_utils.utils.Objects                  import obj_is_attribute_annotation_of_type
+        from osbot_utils.utils.Objects                  import obj_attribute_annotation
+        from osbot_utils.utils.Objects                  import enum_from_value
+        from osbot_utils.helpers.Safe_Id                import Safe_Id
+        from osbot_utils.helpers.Timestamp_Now          import Timestamp_Now
 
         for key, value in data.items():
             if hasattr(self, key) and isinstance(getattr(self, key), Type_Safe):
@@ -327,16 +344,22 @@ class Type_Safe:
         return self
 
     def obj(self):
+        from osbot_utils.utils.Objects import dict_to_obj
+
         return dict_to_obj(self.json())
 
     def serialize_to_dict(self):                        # todo: see if we need this method or if the .json() is enough
         return serialize_to_dict(self)
 
     def print(self):
+        from osbot_utils.utils.Dev import pprint
+
         pprint(serialize_to_dict(self))
 
     @classmethod
     def from_json(cls, json_data, raise_on_not_found=False):
+        from osbot_utils.utils.Json import json_parse
+
         if type(json_data) is str:
             json_data = json_parse(json_data)
         if json_data:                                           # if there is no data or is {} then don't create an object (since this could be caused by bad data being provided)
@@ -345,6 +368,10 @@ class Type_Safe:
 
 # todo: see if it is possible to add recursive protection to this logic
 def serialize_to_dict(obj):
+    from decimal import Decimal
+    from enum    import Enum
+    from typing  import List
+
     if isinstance(obj, (str, int, float, bool, bytes, Decimal)) or obj is None:
         return obj
     elif isinstance(obj, Enum):
@@ -361,3 +388,5 @@ def serialize_to_dict(obj):
         return data
     else:
         raise TypeError(f"Type {type(obj)} not serializable")
+        #return f"UNSERIALIZABLE({type(obj).__name__})"             # todo: see if there are valid use cases for this
+

osbot_utils/decorators/lists/group_by.py

@@ -1,8 +1,9 @@
 #todo: refactor with index_by
-from functools import wraps
 
 
 def group_by(function):                                 # returns the list provided grouped by the key provided in group_by
+    from functools import wraps
+
     @wraps(function)
     def wrapper(*args,**kwargs):
         key = None

osbot_utils/decorators/lists/index_by.py

@@ -1,11 +1,11 @@
 # todo: find way to also allow the used of function().index_by(key) to working
 #     : maybe using Fluent_List
-from functools import wraps
-
-from osbot_utils.fluent.Fluent_Dict import Fluent_Dict
 
 
 def index_by(function):                                 # returns the list provided indexed by the key provided in index_by
+    from functools import wraps
+    from osbot_utils.fluent.Fluent_Dict import Fluent_Dict
+
     def apply(key, values):
         if key:
             results = {}

osbot_utils/decorators/methods/cache_on_self.py

@@ -1,9 +1,5 @@
-import inspect
-from functools              import wraps
-from osbot_utils.utils.Misc import str_md5
 from typing                 import Any, Callable, TypeVar
 
-
 CACHE_ON_SELF_KEY_PREFIX = '__cache_on_self__'
 CACHE_ON_SELF_TYPES      = [int, float, bytearray, bytes, bool,
                             complex, str]
@@ -17,12 +13,14 @@ CACHE_ON_SELF_TYPES      = [int, float, bytearray, bytes, bool,
 
 T = TypeVar('T', bound=Callable[..., Any])      # so that we have type hinting when using this class
 
-def cache_on_self(function: T) -> T:
-    """
-    Use this for cases where we want the cache to be tied to the Class instance (i.e. not global for all executions)
-    """
+def cache_on_self(function: T) -> T:            # Use this for cases where we want the cache to be tied to the Class instance (i.e. not global for all executions)
+    import inspect
+    from functools import wraps
+
     @wraps(function)
     def wrapper(*args, **kwargs):
+
+
         if len(args) == 0 or inspect.isclass(type(args[0])) is False:
             raise Exception("In Method_Wrappers.cache_on_self could not find self")
 
@@ -58,23 +56,25 @@ def cache_on_self__kwargs_to_str(kwargs):
     return kwargs_values_as_str
 
 def cache_on_self__get_cache_in_key(function, args=None, kwargs=None):
-        key_name   = function.__name__
-        args_md5   = ''
-        kwargs_md5 = ''
-        args_values_as_str   = cache_on_self__args_to_str(args)
-        kwargs_values_as_str = cache_on_self__kwargs_to_str(kwargs)
-        if args_values_as_str:
-            args_md5 = str_md5(args_values_as_str)
-        if kwargs_values_as_str:
-            kwargs_md5 = str_md5(kwargs_values_as_str)
-        return f'{CACHE_ON_SELF_KEY_PREFIX}_{key_name}_{args_md5}_{kwargs_md5}'
-
-        # class_name = self_obj.__class__.__name__
-        #
-        # function_name = function_obj.__name__
-        # if params:
-        #     params_as_string = '_'.join(str(x) for x in params).replace('/',' ')
-        #     params_md5       = str_md5(params_as_string)
-        #     return f'{class_name}_{function_name}_{params_md5}.gz'
-        # else:
-        #     return f'{class_name}_{function_name}.gz'
+    from osbot_utils.utils.Misc import str_md5
+
+    key_name   = function.__name__
+    args_md5   = ''
+    kwargs_md5 = ''
+    args_values_as_str   = cache_on_self__args_to_str(args)
+    kwargs_values_as_str = cache_on_self__kwargs_to_str(kwargs)
+    if args_values_as_str:
+        args_md5 = str_md5(args_values_as_str)
+    if kwargs_values_as_str:
+        kwargs_md5 = str_md5(kwargs_values_as_str)
+    return f'{CACHE_ON_SELF_KEY_PREFIX}_{key_name}_{args_md5}_{kwargs_md5}'
+
+    # class_name = self_obj.__class__.__name__
+    #
+    # function_name = function_obj.__name__
+    # if params:
+    #     params_as_string = '_'.join(str(x) for x in params).replace('/',' ')
+    #     params_md5       = str_md5(params_as_string)
+    #     return f'{class_name}_{function_name}_{params_md5}.gz'
+    # else:
+    #     return f'{class_name}_{function_name}.gz'

osbot_utils/decorators/methods/remove_return_value.py

@@ -1,14 +1,11 @@
-from functools import wraps
+class remove_return_value:          # removes the field from the return value of the function (if it exists)
 
-
-class remove_return_value:
-    """
-    removes the field from the return value of the function (if it exists)
-    """
     def __init__(self, field_name):
         self.field_name = field_name                                # field to remove
 
     def __call__(self, function):
+        from functools import wraps
+
         @wraps(function)                                            # makes __name__ work ok
         def wrapper(*args,**kwargs):                                # wrapper function
             data = function(*args,**kwargs)                         # calls wrapped function with original params

osbot_utils/helpers/Random_Guid.py

@@ -1,7 +1,9 @@
-from osbot_utils.utils.Misc import random_guid, is_guid
+
 
 class Random_Guid(str):
     def __new__(cls, value=None):
+        from osbot_utils.utils.Misc import random_guid, is_guid
+
         if value is None:
             value = random_guid()
         if is_guid(value):

osbot_utils/helpers/Timestamp_Now.py

@@ -1,12 +1,15 @@
-from osbot_utils.utils.Misc import timestamp_now
 
 class Timestamp_Now(int):
     def __new__(cls, value=None):
+        from osbot_utils.utils.Misc import timestamp_now
+
         if value is None:
             value = timestamp_now()
         return int.__new__(cls, value)
 
     def __init__(self, value=None):
+        from osbot_utils.utils.Misc import timestamp_now
+
         self.value = value if value is not None else timestamp_now()
 
     def __str__(self):

osbot_utils/helpers/generators/Generator_Manager.py

@@ -8,6 +8,7 @@ from osbot_utils.helpers.Random_Guid                            import Random_Gu
 from osbot_utils.helpers.generators.Generator_Context_Manager   import Generator_Context_Manager
 from osbot_utils.helpers.generators.Model__Generator_State      import Model__Generator_State
 from osbot_utils.helpers.generators.Model__Generator_Target     import Model__Generator_Target
+from osbot_utils.utils.Lists                                    import list_group_by
 
 
 class Generator_Manager(Type_Safe):                                                                        # Class for managing multiple generator targets
@@ -92,6 +93,21 @@ class Generator_Manager(Type_Safe):
                     stopped_count += 1                                                                     # Increment the stopped count if successful
             return stopped_count                                                                           # Return the total number of stopped generators
 
+    def status(self):
+        items = []
+        for _, generator in self.generators.items():
+            item = dict(target_method_name = generator.target.__name__,
+                        target_state       = generator.state.value,
+                        target_id          = generator.target_id )
+            items.append(item)
+        items__by_state = list_group_by(items, 'target_state')
+        result = {}
+        for state, items in items__by_state.items():
+            result[state] = len(items)
+        result['data'] = items__by_state
+        return result
+
+
     def target_id(self, target: GeneratorType) -> Union[Random_Guid, None]:                                # Method to get the ID of a specific generator
         with self.lock:                                                                                    # Acquire the lock for thread-safe access
             for generator in list(self.generators.values()):                                               # Iterate over the generator targets

osbot_utils/helpers/sqlite/Sqlite__Database.py

@@ -1,18 +1,14 @@
-import sqlite3
-
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.decorators.methods.cache import cache
-from osbot_utils.decorators.methods.cache_on_self import cache_on_self
-
-from osbot_utils.utils.Files import current_temp_folder, path_combine, folder_create, file_exists, file_delete
-from osbot_utils.utils.Misc import  random_filename
+from osbot_utils.base_classes.Type_Safe             import Type_Safe
+from osbot_utils.decorators.methods.cache_on_self   import cache_on_self
+from osbot_utils.utils.Files                        import current_temp_folder, path_combine, folder_create, file_exists, file_delete
+from osbot_utils.utils.Misc                         import  random_filename
 
 SQLITE_DATABASE_PATH__IN_MEMORY = ':memory:'
 FOLDER_NAME_TEMP_DATABASES      = '_temp_sqlite_databases'
 TEMP_DATABASE__FILE_NAME_PREFIX = 'random_sqlite_db__'
 TEMP_DATABASE__FILE_EXTENSION   = '.sqlite'
 
-class Sqlite__Database(Kwargs_To_Self):
+class Sqlite__Database(Type_Safe):
     db_path         : str  = None
     closed          : bool = False
     connected       : bool = False
@@ -38,6 +34,8 @@ class Sqlite__Database(Kwargs_To_Self):
 
     @cache_on_self
     def connect(self):
+        import sqlite3
+
         connection_string      = self.connection_string()
         connection             = sqlite3.connect(connection_string)
         connection.row_factory = self.dict_factory                      # this returns a dict as the row value of every query
@@ -90,6 +88,8 @@ class Sqlite__Database(Kwargs_To_Self):
         return path_temp_databases
 
     def save_to(self, path):
+        import sqlite3
+
         connection = self.connection()
         file_conn  = sqlite3.connect(path)
         connection.backup(file_conn)

osbot_utils/helpers/sqlite/domains/Sqlite__DB__Files.py

@@ -1,7 +1,7 @@
-from osbot_utils.decorators.lists.index_by import index_by
-from osbot_utils.decorators.methods.cache_on_self import cache_on_self
-from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local import Sqlite__DB__Local
-from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Files import Sqlite__Table__Files
+from osbot_utils.decorators.lists.index_by                  import index_by
+from osbot_utils.decorators.methods.cache_on_self           import cache_on_self
+from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local   import Sqlite__DB__Local
+
 
 
 class Sqlite__DB__Files(Sqlite__DB__Local):
@@ -35,6 +35,8 @@ class Sqlite__DB__Files(Sqlite__DB__Local):
 
     @cache_on_self
     def table_files(self):
+        from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Files import Sqlite__Table__Files
+
         return Sqlite__Table__Files(database=self).setup()
 
     @index_by

osbot_utils/helpers/trace/Trace_Call__Config.py

@@ -1,11 +1,13 @@
-from osbot_utils.utils.Dev                   import pprint
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+from osbot_utils.utils.Dev              import pprint                   # todo: fix test requirement of mock to use this method
+
 
 PRINT_MAX_STRING_LENGTH    = 100
 PRINT_PADDING__DURATION    = 100
 PRINT_PADDING_PARENT_INFO  = 60
 
-class Trace_Call__Config(Kwargs_To_Self):
+class Trace_Call__Config(Type_Safe):
     capture_locals             : bool = False
     capture_duration           : bool
     capture_extra_data         : bool

osbot_utils/utils/Dev.py

@@ -1,26 +1,29 @@
-import json
-import pprint as original_pprint
-
-from osbot_utils.utils.Misc import date_time_now
-
 
 class Dev:
     @staticmethod
     def jformat(data):
+        import json
+
         return json.dumps(data, indent=4)       # use json.dumps to format
 
     @staticmethod
     def jprint(data):
+        import json
+
         print()                                 # add a line before
         print(json.dumps(data, indent=4))       # use json.dumps to format
         return data
 
     @staticmethod
     def pformat(data):
+        import pprint as original_pprint
+
         return original_pprint.pformat(data, indent=2)  # use a pprint to format
 
     @staticmethod
     def pprint(*args):
+        import pprint as original_pprint
+
         print()                                # add a line before
         for arg in args:
             original_pprint.pprint(arg, indent=2)       # use a pprint to format
@@ -36,6 +39,8 @@ class Dev:
 
     @staticmethod
     def print_now():
+        from osbot_utils.utils.Misc import date_time_now
+
         print(date_time_now())
 
 jformat   = Dev.jformat

osbot_utils/utils/Env.py

@@ -1,12 +1,6 @@
-
-import os
-import sys
-from sys                        import platform
-from osbot_utils.utils.Files    import all_parent_folders, file_exists
-from osbot_utils.utils.Misc     import list_set
-from osbot_utils.utils.Str      import strip_quotes
-
 def del_env(key):
+    import os
+
     if key in os.environ:
         del os.environ[key]
 
@@ -14,6 +8,8 @@ def env__home():
     return get_env('HOME', '')
 
 def env__home__is__root():
+    import os
+
     return os.getenv('HOME') == '/root'
 
 def env__old_pwd():
@@ -28,6 +24,8 @@ def env__old_pwd__remove(value):
     return value
 
 def env__terminal__is__xterm():
+    import os
+
     return os.getenv('TERM') == 'xterm'
 
 def env__terminal__is_not__xterm():
@@ -35,16 +33,21 @@ def env__terminal__is_not__xterm():
 
 
 def platform_darwin():
+    from sys import platform
     return platform == 'darwin'
 
 def env_value(var_name):
     return env_vars().get(var_name, None)
 
 def env_var_set(var_name):
+    import os
+
     value = os.getenv(var_name)
     return value is not None and value != ''
 
 def env_vars_list():
+    from osbot_utils.utils.Misc import list_set
+
     return list_set(env_vars())
 
 def env_vars(reload_vars=False):
@@ -52,6 +55,8 @@ def env_vars(reload_vars=False):
     if reload_vars reload data from .env file
     then return dictionary with current environment variables
     """
+    import os
+
     if reload_vars:
         load_dotenv()
     vars = os.environ
@@ -61,7 +66,12 @@ def env_vars(reload_vars=False):
     return data
 
 def env_load_from_file(path, override=False):
+    import os
+    from osbot_utils.utils.Files import file_exists
+
     if file_exists(path):
+        from osbot_utils.utils.Str import strip_quotes
+
         with open(path) as f:
             for line in f:
                 line = line.strip()
@@ -75,6 +85,8 @@ def env_load_from_file(path, override=False):
                     os.environ[key.strip()] = value.strip()
 
 def env_unload_from_file(path):
+    import os
+
     if os.path.exists(path):
         with open(path) as f:
             for line in f:
@@ -87,19 +99,33 @@ def env_unload_from_file(path):
                     del os.environ[key]
 
 def find_dotenv_file(start_path=None, env_file_to_find='.env'):
+    import os
+    from osbot_utils.utils.Files import all_parent_folders
+
     directories = all_parent_folders(path=start_path, include_path=True)  # Define the possible directories to search for the .env file (which is this and all parent folders)
     for directory in directories:                                         # Iterate through the directories and load the .env file if found
         env_path = os.path.join(directory,env_file_to_find)               # Define the path to the .env file
         if os.path.exists(env_path):                                      # If we found one
             return env_path                                               # return the path to the .env file
 
+def get_env(key, default=None):
+    import os
+    return os.getenv(key, default=default)
+
 def in_github_action():
+    import os
+
     return os.getenv('GITHUB_ACTIONS') == 'true'
 
 def in_pytest_with_coverage():
+    import os
+
     return os.getenv('COVERAGE_RUN') == 'true'
 
 def in_python_debugger():
+    import os
+    import sys
+
     if sys.gettrace() is not None:              # Check for a trace function
         return True
     pycharm_hosted           = os.getenv('PYCHARM_HOSTED') == '1'                     # Check for PyCharm specific environment variables and other potential indicators
@@ -121,10 +147,15 @@ def not_in_github_action():
     return in_github_action() is False
 
 def set_env(key, value):
+    import os
+
     os.environ[key] = value
     return value
 
 def unload_dotenv(dotenv_path=None):
+    import os
+    from osbot_utils.utils.Files import all_parent_folders
+
     if dotenv_path:                                                 # If a specific dotenv path is provided, unload from it
         env_unload_from_file(dotenv_path)
     else:
@@ -136,5 +167,4 @@ def unload_dotenv(dotenv_path=None):
                 break                                               # Stop after unloading the first .env file
 
 is_env_var_set = env_var_set
-env_load       = load_dotenv
-get_env        = os.getenv
+env_load       = load_dotenv