abstract-utilities 0.2.2.513__py3-none-any.whl → 0.2.2.627__py3-none-any.whl

abstract_utilities/import_utils/src/clean_imports.py

@@ -1,12 +1,64 @@
 from ..imports import *
 from .pkg_utils import *
-
+from ...safe_utils import *
+def is_local_import(line):
+    print(line)
+    imports_from_import_pkg = clean_imports(line)
+    input(imports_from_import_pkg)
+def try_is_file(file_path):
+    try:
+        return os.path.isfile(file_path)
+    except:
+        return False
+def try_is_dir(file_path):
+    try:
+        return os.path.isdir(file_path)
+    except:
+        return False
+def try_join(*args):
+    try:
+        return safe_join(*args)
+    except:
+        return False
+def get_pkg_or_init(pkg_path):
+    if pkg_path:
+        if try_is_file(pkg_path):
+            return pkg_path
+        pkg_py_path = f"{pkg_path}.py"
+        if try_is_file(pkg_py_path):
+            return pkg_py_path
+        pkg_init_path = try_join(pkg_path,'__init__.py')
+        if try_is_dir(pkg_path):
+            if os.path.isfile(pkg_init_path):
+                return pkg_init_path
+def get_text_and_file_and_js(text=None,file_path=None,import_pkg_js=None):
+    inputs = {"text":text,"file_path":file_path,"import_pkg_js":import_pkg_js}
+    for key,value in inputs.items():
+        if value:
+            if isinstance(value,str):
+                _file_path = get_pkg_or_init(file_path)
+                if _file_path:
+                    file_path=_file_path
+                    if key == "text" or text == None:
+                        text=read_from_file(file_path)
+                if isinstance(value,dict):
+                    if key in ["text","file_path"]:
+                        if key == "text":
+                            text = None
+                        if key == "file_path":
+                            file_path = None
+                    import_pkg_js=value
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
+    return text,file_path,import_pkg_js
 def get_text_or_read(text=None,file_path=None):
-    text = text or ''
-    imports_js = {}
-    if not text and file_path and os.path.isfile(file_path):
+    file_path = get_pkg_or_init(file_path)
+    if not text and file_path:
         text=read_from_file(file_path)
-    return text
+    if text and not file_path:
+        file_path=get_pkg_or_init(text)
+        if file_path:
+            text = None
+    return text,file_path 
 def is_line_import(line):
     if line and (line.startswith(FROM_TAG) or line.startswith(IMPORT_TAG)):
         return True
@@ -25,19 +77,18 @@ def is_from_line_group(line):
     return False
 
 def get_all_imports(text=None,file_path=None,import_pkg_js=None):
-    if text and os.path.isfile(text):
-        file_path = text
-        text = read_from_file(text)    
-    text = get_text_or_read(text=text,file_path=file_path)
+    text,file_path = get_text_or_read(text=text,file_path=file_path)
     lines = text.split('\n')
     cleaned_import_list=[]
     nu_lines = []
     is_from_group = False
     import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
     for line in lines:
+        
         if line.startswith(IMPORT_TAG) and ' from ' not in line:
+            
             cleaned_import_list = get_cleaned_import_list(line)
-            import_pkg_js = add_imports_to_import_pkg_js("import",cleaned_import_list,import_pkg_js=import_pkg_js)
+            import_pkg_js = add_imports_to_import_pkg_js("import",cleaned_import_list,import_pkg_js=import_pkg_js,file_path=file_path)
         else:
             if is_from_group:
                 import_pkg=is_from_group
@@ -46,18 +97,16 @@ def get_all_imports(text=None,file_path=None,import_pkg_js=None):
                    is_from_group=False
                    line=line[:-1]
                 imports_from_import_pkg = clean_imports(line)
-                import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports_from_import_pkg,import_pkg_js=import_pkg_js)
+                import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports_from_import_pkg,import_pkg_js=import_pkg_js,file_path=file_path)
                 
             else:
-                import_pkg_js=update_import_pkg_js(line,import_pkg_js=import_pkg_js)
+                import_pkg_js=update_import_pkg_js(line,import_pkg_js=import_pkg_js,file_path=file_path)
             if is_from_line_group(line) and is_from_group == False:
                 is_from_group=get_import_pkg(line)
     return import_pkg_js
 
-def clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
-    if text and os.path.isfile(text):
-        file_path = text
-        text = read_from_file(text)    
+def get_clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
+    text,file_path,_ = get_text_and_file_and_js(text=text,file_path=file_path,import_pkg_js=import_pkg_js)   
     if not import_pkg_js:
         import_pkg_js = get_all_imports(text=text,file_path=file_path)
     import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
@@ -87,11 +136,11 @@ def clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False
                     nu_lines[line] += imports
     return import_pkg_js
 def clean_all_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
-    clean_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js,fill_nulines=import_pkg_js)
-    import_pkg_js["context"]["nulines"]=nu_lines
+    import_pkg_js = get_clean_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js,fill_nulines=import_pkg_js)
+    import_pkg_js["context"]["nulines"]=import_pkg_js["context"]["nulines"]
     return import_pkg_js
 def get_clean_import_string(import_pkg_js,fill_nulines=False,get_locals=False):
-    import_pkg_js = clean_imports(import_pkg_js=import_pkg_js,fill_nulines=fill_nulines)
+    import_pkg_js = get_clean_imports(import_pkg_js=import_pkg_js,fill_nulines=fill_nulines)
     import_ls = []
     for key,values in import_pkg_js.items():
         if key not in ['context','nulines']:
@@ -130,18 +179,100 @@ def get_dot_fro_lines(lines,file_path,all_imps):
             all_imps.append(line)
     return all_imps
 def get_all_real_imps(text=None,file_path=None,all_imps=None):
-    if text and os.path.isfile(text):
-        file_path = text
-        text = read_from_file(text)    
+  
     all_imps = all_imps or []
-    contents = get_text_or_read(text=text,file_path=file_path)
-    lines = contents.split('\n')
+    text,file_path = get_text_or_read(text=text,file_path=file_path)
+    lines = text.split('\n')
     all_imps = get_dot_fro_lines(lines,file_path,all_imps)
     return '\n'.join(all_imps)
 def save_cleaned_imports(text=None,file_path=None,write=False,import_pkg_js=None):
-    import_pkg_js=get_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    text,file_path,import_pkg_js = get_text_and_file_and_js(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
     import_pkg_js = clean_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
     contents = '\n'.join(import_pkg_js["context"]["nulines"])
     if file_path and write:
         write_to_file(contents=contents,file_path=file_path)
     return contents
+def convert_to_sysroot_relative(import_pkg, file_path, sysroot):
+    """
+    Convert an absolute package import into a dotted relative import based on
+    the file's depth inside sysroot.
+    """
+
+    if not sysroot:
+        return import_pkg  # no conversion
+
+    file_path = os.path.abspath(file_path)
+    sysroot = os.path.abspath(sysroot)
+
+    # Ignore imports outside sysroot
+    file_dir = os.path.dirname(file_path)
+    if not file_dir.startswith(sysroot):
+        return import_pkg
+
+    # Compute how many directories deep the file is
+    rel = os.path.relpath(file_dir, sysroot)
+    depth = 0 if rel == "." else len(rel.split(os.sep))
+
+    # Depth N means N dots (i.e. N relative levels)
+    dots = "." * depth
+
+    return f"{dots}{import_pkg}"
+
+import os
+
+def rewrite_import_with_sysroot(line, file_path, sysroot):
+    """
+    Rewrite imports like:
+        from imports.constants import *
+    into:
+        from <relative_path>.imports.constants import *
+    Where <relative_path> is computed relative to sysroot.
+    """
+
+    line = line.rstrip()
+    if not line.startswith("from "):
+        return line
+
+    # Split import structure
+    try:
+        after_from = line[len("from "):]
+        pkg, after_import = after_from.split(" import ", 1)
+    except ValueError:
+        return line  # Not a normal from X import Y
+
+    # Absolute paths
+    file_dir = os.path.dirname(os.path.abspath(file_path))
+    sysroot = os.path.abspath(sysroot)
+
+    # Compute relative path
+    relpath = os.path.relpath(file_dir, sysroot)
+
+    # Turn filesystem path into dotted python path
+    if relpath == ".":
+        dotted = ""
+    else:
+        dotted = ".".join(part for part in relpath.split(os.sep) if part)
+
+    # Import path you want to append the old import to
+    new_pkg = f"{dotted}.{pkg}".lstrip('.')
+
+    # Build final rewritten import
+    return f"from {new_pkg} import {after_import}"
+
+def trace_all_imports(file_path, sysroot=None):
+    import_pkg_js = {}
+    files = collect_filepaths(file_path, allowed_exts='.py', add=True)
+
+    for file in files:
+        text = get_all_real_imps(file_path=file)
+        lines = text.split("\n")
+
+        if sysroot:
+            new_lines = []
+            for line in lines:
+                new_lines.append(rewrite_import_with_sysroot(line, file, sysroot))
+            text = "\n".join(new_lines)
+
+        import_pkg_js = get_all_imports(text=text, file_path=file, import_pkg_js=import_pkg_js)
+
+    return get_clean_import_string(import_pkg_js)

abstract_utilities/import_utils/src/dot_utils.py

@@ -1,4 +1,15 @@
 from ..imports import *
+def find_top_package_dir(p: Path) -> Path | None:
+    p = p.resolve()
+    if p.is_file():
+        p = p.parent
+    top = None
+    while (p / "__init__.py").exists():
+        top = p
+        if p.parent == p:
+            break
+        p = p.parent
+    return top
 def get_Path(path):
     if isinstance(path,str):
         path = Path(str(path))

abstract_utilities/import_utils/src/extract_utils.py

@@ -40,3 +40,7 @@ def extract_class(path: str):
         if m:
             funcs.append(m.group(1))
     return funcs
+def get_all_py_file_paths(directory,*args,**kwargs):
+    globs = collect_globs(directory,*args,allowed_exts='.py',**kwargs)
+    globs = [glo for glo in globs.get('files') if glo]
+    return globs

abstract_utilities/import_utils/src/import_functions.py

@@ -1,7 +1,8 @@
 # --- auto-package bootstrap (run-safe) ---------------------------------
 from ..imports import *
 from .dot_utils import get_dot_range
-from .sysroot_utils import get_sysroot
+from .sysroot_utils import get_sysroot,get_import_with_sysroot,get_py_files,get_all_py_sysroots
+from .extract_utils import get_all_py_file_paths
 def clean_imports(imports,commaClean=True):
     chars=["*"]
     if not commaClean:
@@ -9,6 +10,13 @@ def clean_imports(imports,commaClean=True):
     if isinstance(imports,str):
         imports = imports.split(',')
     return [eatElse(imp,chars=chars) for imp in imports if imp]
+def get_dot_range(import_pkg):
+    count = 0
+    for char in import_pkg:
+        if char != '.':
+            break
+        count+=1
+    return count
 def get_cleaned_import_list(line,commaClean=True):
     cleaned_import_list=[]
     if IMPORT_TAG in line:
@@ -17,7 +25,7 @@ def get_cleaned_import_list(line,commaClean=True):
     return cleaned_import_list
 def get_module_from_import(imp,path=None):
     path = path or os.getcwd()
-    i = get_dot_range(None,[imp])
+    i = get_dot_range(imp)
     imp = eatAll(imp,'.')
     sysroot = get_sysroot(path,i)
     return os.path.join(sysroot, imp)
@@ -42,5 +50,61 @@ def safe_import(name: str, *, package: str | None = None, member: str | None = N
     mod = importlib.import_module(name, package=package)
     return getattr(mod, member) if member else mod
 
+def dynamic_import(module_path: str, namespace: dict, all_imports = None):
+    """
+    Emulates:
+        from module_path import *
+    but includes private (_xxx) names too.
+    """
+    all_imports = if_none_change(all_imports,True)
+    if module_path:
+        module = importlib.import_module(module_path)
+        # Import literally everything except dunders, unless you want them too.
+        names = [n for n in dir(module) if n and ((not all_imports and not n.startswith("_")) or all_imports)]
+        for name in names:
+            namespace[name] = getattr(module, name)
+        return module
+def get_monorepo_root(directory=None,files=None):
+    directory = directory or get_initial_caller_dir()
+    
+    py_files = get_all_py_file_paths(directory,add=True)
+    sysroots = get_all_py_sysroots(directory=directory,files=py_files)
+    monorepo_root = get_common_root(sysroots)
+    return monorepo_root
+def switch_to_monorepo_root(directory=None,files=None):
+    monorepo_root = get_monorepo_root(directory=directory,files=files)
+    if str(monorepo_root) not in sys.path:
+        sys.path.insert(0, str(monorepo_root))
+    return str(monorepo_root)
+def get_all_imports(directory=None,sysroot=None,globs=None):
+    globs = globs or get_true_globals() or globals()
+    directory = directory or get_initial_caller_dir()
+    files = collect_globs(directory=directory,allowed_exts='.py').get('files')
+    sysroot = sysroot or switch_to_monorepo_root(directory=directory,files=files)
+    for glo in files:
+        imp = get_import_with_sysroot(glo, sysroot)
+        dynamic_import(imp, globs)
+def get_all_imports_for_class(self, directory=None, sysroot=None, include_private=True):
+    """
+    Load all modules under `directory` and assign their exports as attributes
+    on the class instance (self).
+    """
+    directory = directory or get_initial_caller_dir()
+    files = collect_globs(directory=directory, allowed_exts='.py').get("files")
+
+    # Compute sysroot (monorepo root)
+    sysroot = sysroot or switch_to_monorepo_root(directory=directory, files=files)
+
+    for glo in files:
+        mod_path = get_import_with_sysroot(glo, sysroot)
+        module = importlib.import_module(mod_path)
+
+        for name in dir(module):
+            if name.startswith("__"):
+                continue
+            if not include_private and name.startswith("_"):
+                continue
 
+            setattr(self, name, getattr(module, name))
 
+    return self

abstract_utilities/import_utils/src/pkg_utils.py

@@ -1,6 +1,36 @@
 # safe_import_utils.py
 from ..imports import *
 from .import_functions import *
+from ...safe_utils import *
+from .sysroot_utils import get_import_with_sysroot
+def try_is_file(file_path):
+    try:
+        return os.path.isfile(file_path)
+    except:
+        return False
+def try_is_dir(file_path):
+    try:
+        return os.path.isdir(file_path)
+    except:
+        return False
+def try_join(*args):
+    try:
+        return safe_join(*args)
+    except:
+        return False
+def get_pkg_or_init(pkg_path):
+    if pkg_path:
+        if try_is_file(pkg_path):
+            return pkg_path
+        pkg_py_path = f"{pkg_path}.py"
+        if try_is_file(pkg_py_path):
+            return pkg_py_path
+        pkg_init_path = try_join(pkg_path,'__init__.py')
+        if try_is_dir(pkg_path):
+            if os.path.isfile(pkg_init_path):
+                return pkg_init_path
+
+
 
 def ensure_import_pkg_js(import_pkg_js,file_path=None):
     import_pkg_js = import_pkg_js or {"context":{}}
@@ -79,18 +109,42 @@ def ensure_caller_package(caller_file: str, caller_globals: dict | None = None)
     if caller_globals and caller_globals.get("__name__") == "__main__" and not caller_globals.get("__package__"):
         caller_globals["__package__"] = pkg
     return pkg
+def get_init_dots(import_pkg):
+    count = 0
+    for char in import_pkg:
+        if char != '.':
+            break
+        count+=1
+    return count
+def make_relative_pkg(import_pkg,file_path):
+    full_pkg = eatAll(import_pkg,'.')
+    if file_path:
+        dirname = file_path
+        dot_count = get_init_dots(import_pkg)
+        for i in range(dot_count):
+            dirname = os.path.dirname(dirname)
+            dirbase = os.path.basename(dirname)
+            full_pkg=f"{dirbase}.{full_pkg}"
+    return full_pkg
+def is_local_import(import_pkg,file_path=None):
+    relative_pkg = get_module_from_import(import_pkg,file_path)
+    if get_pkg_or_init(relative_pkg):
+        return True
+    return False
 def get_import_pkg(line):
     if is_line_group_import(line):
         return clean_line(line.split(FROM_TAG)[1].split(IMPORT_TAG)[0])
 def get_imports_from_import_pkg(line):
     if is_line_group_import(line):
         return get_cleaned_import_list(line,commaClean=True)
-def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None):
+def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None,file_path=None):
     import_pkg_js = ensure_import_pkg_js(import_pkg_js)
     imports = clean_imports(imports)
+    pkg_path = get_module_from_import(import_pkg,file_path)
+    local_import = get_pkg_or_init(pkg_path)
     if import_pkg not in import_pkg_js:
         i = len(import_pkg_js["context"]["nulines"])
-        import_pkg_js[import_pkg]={"imports":imports,"line":i}
+        import_pkg_js[import_pkg]={"imports":imports,"line":i,"file_path":file_path,"local_import":local_import,"is_local":is_local_import(import_pkg,file_path=file_path)}
         import_line = f"from {import_pkg} import "
         if import_pkg == "import":
             import_line = IMPORT_TAG
@@ -98,12 +152,12 @@ def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None):
     else:
         import_pkg_js[import_pkg]["imports"]+=imports
     return import_pkg_js
-def update_import_pkg_js(line,import_pkg_js=None):
+def update_import_pkg_js(line,import_pkg_js=None,file_path=None):
     import_pkg_js = ensure_import_pkg_js(import_pkg_js)
     if is_line_group_import(line):
         import_pkg = get_import_pkg(line)
         imports = get_imports_from_import_pkg(line)
-        import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=import_pkg_js)
+        import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=import_pkg_js,file_path=file_path)
     else:
         if len(import_pkg_js["context"]["nulines"]) >0 and line == '' and is_line_import(import_pkg_js["context"]["nulines"][-1]):
             pass

abstract_utilities/import_utils/src/sysroot_utils.py

@@ -1,6 +1,9 @@
 from ..imports import *
 from .dot_utils import *
-
+from .extract_utils import get_all_py_file_paths
+def get_py_files(directory=None):
+    directory = directory or get_initial_caller_dir()
+    return get_all_py_file_paths(directory,add=True)
 def ensure_on_path(p: Path):
     s = str(p)
     if s not in sys.path:
@@ -19,7 +22,59 @@ def get_dot_range_sysroot(filepath):
         sysroot = get_sysroot(sysroot,dot_range)
     
     return sysroot
+def get_import_with_sysroot(file_path, sysroot):
+    """
+    Rewrite imports like:
+        from imports.constants import *
+    into:
+        from <relative_path>.imports.constants import *
+    Where <relative_path> is computed relative to sysroot.
+    """
+
+
+    # Absolute paths
+    file_dir = os.path.dirname(os.path.abspath(file_path))
+    sysroot = os.path.abspath(sysroot)
+
+    # Compute relative path
+    relpath = os.path.relpath(file_dir, sysroot)
+
+    bare_rel = eatAll(relpath,'.')
+    
+    # Turn filesystem path into dotted python path
+    if relpath == ".":
+        dotted = ""
+    else:
+        dotted = ".".join(part for part in relpath.split(os.sep) if part)
+    if bare_rel.startswith('/') and dotted.startswith('.'):
+        dotted = dotted[1:]
+
+
+    # Build final rewritten import
+    return dotted
+def get_all_sysroots(files):
+    sysroots=[]
+    for glo in files:
+        imp = compute_dotted_and_sysroot(glo)
+        sysroots.append(imp[-1])
+    return sysroots
+def get_shortest_sysroot(files):
+    sysroots = get_all_sysroots(files)
+    return get_shortest_path(*sysroots)
+def get_all_py_sysroots(directory=None,files=None):
+    py_files = files or get_py_files(directory=directory)
+    return [compute_dotted_and_sysroot(glo)[1] for glo in py_files]
 
+def get__imports(directory=None, sysroot=None):
+    directory = directory or get_caller_dir(1)
+    globs = collect_globs(directory, allowed_exts='.py')
+    globs = [glo for glo in globs.get('files') if glo]
+    sysroots = [compute_dotted_and_sysroot(glo)[1] for glo in globs]
+    # ⭐ Get unified monorepo root
+    monorepo_root = get_common_root(sysroots)
+    if str(monorepo_root) not in sys.path:
+        sys.path.insert(0, str(monorepo_root))
+    get_all_imports(directory=directory, sysroot=monorepo_root)
 def is_import_or_init(sysroot,likely=None):
     file_data = get_file_parts(sysroot)
     nuroot = sysroot

abstract_utilities/log_utils/log_file.py

@@ -1,41 +1,90 @@
 from .imports import *
-def get_logFile(bpName: str = None, maxBytes: int = 100_000, backupCount: int = 3) -> logging.Logger:
+import os, sys, inspect, logging
+from logging.handlers import RotatingFileHandler
+
+PACKAGE_NAME = "abstract_utilities"   # ← update if needed
+
+
+def _resolve_log_root():
+    """
+    Returns a safe writable logging directory depending on environment:
+    - If running in a virtualenv → <venv>/.logs/<package>
+    - Else if user writable → ~/.cache/<package>/logs
+    - Else → /var/log/<package>
+    """
+    # 1) Virtualenv or Conda environment
+    venv = os.getenv("VIRTUAL_ENV") or os.getenv("CONDA_PREFIX")
+    if venv:
+        root = os.path.join(venv, ".logs", PACKAGE_NAME)
+        os.makedirs(root, exist_ok=True)
+        return root
+
+    # 2) User home cache folder
+    home = os.path.expanduser("~")
+    user_cache_root = os.path.join(home, ".cache", PACKAGE_NAME, "logs")
+    try:
+        os.makedirs(user_cache_root, exist_ok=True)
+        return user_cache_root
+    except PermissionError:
+        pass
+
+    # 3) Last resort: system log dir (requires correct service user permissions)
+    system_root = f"/var/log/{PACKAGE_NAME}"
+    try:
+        os.makedirs(system_root, exist_ok=True)
+        return system_root
+    except PermissionError:
+        # Fail-safe fallback to /tmp
+        fallback = f"/tmp/{PACKAGE_NAME}/logs"
+        os.makedirs(fallback, exist_ok=True)
+        return fallback
+
+
+LOG_ROOT = _resolve_log_root()
+
+
+def get_logFile(bpName=None, maxBytes=100_000, backupCount=3):
     """
-    If bpName is None, use the “caller module’s basename” as the logger name.
-    Otherwise, use the explicitly provided bpName.
+    A logger that always writes to a safe OS-appropriate path.
+    Works even when installed through pip.
     """
     if bpName is None:
-        # Find the first frame outside logging_utils.py
         frame_idx = _find_caller_frame_index()
         frame_info = inspect.stack()[frame_idx]
-        caller_path = frame_info.filename  # e.g. "/home/joe/project/app/routes.py"
+        caller_path = frame_info.filename
         bpName = os.path.splitext(os.path.basename(caller_path))[0]
         del frame_info
 
-    log_dir = mkdirs("logs")
-    log_path = os.path.join(log_dir, f"{bpName}.log")
-
-    logger = logging.getLogger(bpName)
+    logger = logging.getLogger(f"{PACKAGE_NAME}.{bpName}")
     logger.setLevel(logging.INFO)
 
     if not logger.handlers:
-        try:
-            handler = RotatingFileHandler(log_path, maxBytes=maxBytes, backupCount=backupCount)
-            handler.setLevel(logging.INFO)
-
-            fmt = "%(asctime)s - %(levelname)s - %(pathname)s - %(message)s"
-            formatter = logging.Formatter(fmt)
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-
-            console = logging.StreamHandler()
-            console.setLevel(logging.INFO)
-            console.setFormatter(formatter)
-            logger.addHandler(console)
-        except Exception as e:
-            print(f"{e}")
+        log_file = os.path.join(LOG_ROOT, f"{bpName}.log")
+        handler = RotatingFileHandler(log_file, maxBytes=maxBytes, backupCount=backupCount)
+
+        fmt = "%(asctime)s - %(levelname)s - %(pathname)s:%(lineno)d - %(message)s"
+        formatter = logging.Formatter(fmt)
+        handler.setFormatter(formatter)
+
+        logger.addHandler(handler)
+
+        # Console handler (optional; can disable for gunicorn)
+        console = logging.StreamHandler(sys.stdout)
+        console.setFormatter(formatter)
+        logger.addHandler(console)
+
     return logger
 
+
+def _find_caller_frame_index():
+    """Find the correct caller module outside this logger."""
+    for idx, frame_info in enumerate(inspect.stack()):
+        if idx == 0:
+            continue
+        module = inspect.getmodule(frame_info.frame)
+        if module and module.__name__ not in (__name__, "logging"):
+            return idx
+    return 1
 def _find_caller_frame_index():
     """
     Scan up the call stack until we find a frame whose module is NOT logging_utils.

abstract_utilities/parse_utils/parse_utils.py

@@ -64,6 +64,29 @@ def detect_language_from_text(text: str):
 
     likely = [lang for lang, score in scores.items() if score == max_score]
     return likely[0] if len(likely) == 1 else 'uncertain'
+def get_tripple_string(string):
+    nustring = ''
+    for i in range(3):
+        nustring +=string
+    return nustring
+def get_within_quotes(text,quotes=None):
+    quotes_strings = quotes or ["'",'"']
+    in_quotes = []
+    for quotes_string in quotes_strings:
+        if not isinstance(quotes_string,list):
+            tripple= get_tripple_string(quotes_string)
+            texts = [text]
+            if tripple in text:
+                texts= text.split(tripple)
+            for text_part in texts:
+                quote_count = len(text_part) - len(text_part.replace(quotes_string,''))
+                quote_spl = text_part.split(quotes_string)
+                in_quotes+=[quote_spl[i] for i in range(quote_count) if ((i == 1 or i%2 != float(0)) and len(quote_spl) > i)]
+        else:
+            texts= text.split(quotes_string[0])
+            for text in texts:
+                in_quotes.append(text.split(quotes_string[1])[0])
+    return in_quotes
 
 def search_code(code_languages, parts):
     return [data for datas in parts for data in make_list(datas)