jaclang 0.7.11__py3-none-any.whl → 0.7.13__py3-none-any.whl

jaclang/core/importer.py

@@ -15,51 +15,67 @@ from jaclang.core.utils import sys_path_context
 
 
 def handle_directory(
-    module_name: str, full_mod_path: str, mod_bundle: Module
+    module_name: str, full_mod_path: str, mod_bundle: Optional[Module]
 ) -> types.ModuleType:
     """Import from a directory that potentially contains multiple Jac modules."""
     module = types.ModuleType(module_name)
     module.__name__ = module_name
     module.__path__ = [full_mod_path]
+    module.__file__ = None
     module.__dict__["__jac_mod_bundle__"] = mod_bundle
-    if module not in sys.modules:
+    if module_name not in sys.modules:
         sys.modules[module_name] = module
     return module
 
 
 def process_items(
     module: types.ModuleType,
-    items: dict[str, Union[str, bool]],
+    items: dict[str, Union[str, Optional[str]]],
     caller_dir: str,
+    lang: Optional[str],
     mod_bundle: Optional[Module] = None,
     cachable: bool = True,
-) -> None:
+) -> list:
     """Process items within a module by handling renaming and potentially loading missing attributes."""
-    module_dir = (
-        module.__path__[0]
-        if hasattr(module, "__path__")
-        else os.path.dirname(getattr(module, "__file__", ""))
-    )
+    unique_loaded_items = []
+
+    def handle_item_loading(item: str, alias: Union[str, Optional[str]]) -> None:
+        if item:
+            unique_loaded_items.append(item)
+            setattr(module, name, item)
+            if alias and alias != name and not isinstance(alias, bool):
+                setattr(module, alias, item)
+
     for name, alias in items.items():
         try:
             item = getattr(module, name)
-            if alias and alias != name and not isinstance(alias, bool):
-                setattr(module, alias, item)
+            handle_item_loading(item, alias)
         except AttributeError:
-            jac_file_path = os.path.join(module_dir, f"{name}.jac")
-            if hasattr(module, "__path__") and os.path.isfile(jac_file_path):
-                item = load_jac_file(
-                    module=module,
-                    name=name,
-                    jac_file_path=jac_file_path,
-                    mod_bundle=mod_bundle,
-                    cachable=cachable,
-                    caller_dir=caller_dir,
+            if lang == "jac":
+                jac_file_path = (
+                    os.path.join(module.__path__[0], f"{name}.jac")
+                    if hasattr(module, "__path__")
+                    else module.__file__
                 )
-                if item:
-                    setattr(module, name, item)
-                    if alias and alias != name and not isinstance(alias, bool):
-                        setattr(module, alias, item)
+                if jac_file_path and os.path.isfile(jac_file_path):
+                    item = load_jac_file(
+                        module=module,
+                        name=name,
+                        jac_file_path=jac_file_path,
+                        mod_bundle=mod_bundle,
+                        cachable=cachable,
+                        caller_dir=caller_dir,
+                    )
+                    handle_item_loading(item, alias)
+                elif jac_file_path and os.path.isdir(jac_file_path[:-4]):
+                    item = handle_directory(name, jac_file_path[:-4], mod_bundle)
+                    handle_item_loading(item, alias)
+            else:
+                if hasattr(module, "__path__"):
+                    full_module_name = f"{module.__name__}.{name}"
+                    item = importlib.import_module(full_module_name)
+                    handle_item_loading(item, alias)
+    return unique_loaded_items
 
 
 def load_jac_file(
@@ -138,24 +154,23 @@ def jac_importer(
     override_name: Optional[str] = None,
     mod_bundle: Optional[Module | str] = None,
     lng: Optional[str] = "jac",
-    items: Optional[dict[str, Union[str, bool]]] = None,
-) -> Optional[types.ModuleType]:
+    items: Optional[dict[str, Union[str, Optional[str]]]] = None,
+) -> tuple[types.ModuleType, ...]:
     """Core Import Process."""
-    dir_path, file_name = path.split(
-        path.join(*(target.split("."))) + (".jac" if lng == "jac" else ".py")
-    )
+    unique_loaded_items = []
+    dir_path, file_name = path.split(path.join(*(target.split("."))))
     module_name = path.splitext(file_name)[0]
     package_path = dir_path.replace(path.sep, ".")
-
     if (
         not override_name
         and package_path
         and f"{package_path}.{module_name}" in sys.modules
     ):
-        return sys.modules[f"{package_path}.{module_name}"]
+        module = sys.modules[f"{package_path}.{module_name}"]
     elif not override_name and not package_path and module_name in sys.modules:
-        return sys.modules[module_name]
-
+        module = sys.modules[module_name]
+    else:
+        module = None
     valid_mod_bundle = (
         sys.modules[mod_bundle].__jac_mod_bundle__
         if isinstance(mod_bundle, str)
@@ -166,54 +181,61 @@ def jac_importer(
 
     caller_dir = get_caller_dir(target, base_path, dir_path)
     full_target = path.normpath(path.join(caller_dir, file_name))
+    if not module:
+        if os.path.isdir(full_target):
+            module = handle_directory(module_name, full_target, valid_mod_bundle)
+        else:
+            full_target += ".jac" if lng == "jac" else ".py"
+            module_name = path.splitext(file_name)[0]
+            package_path = dir_path.replace(path.sep, ".")
 
-    if lng == "py":
-        module = py_import(
-            target=target,
+            if lng == "py":
+                module, *unique_loaded_items = py_import(
+                    target=target,
+                    items=items,
+                    absorb=absorb,
+                    mdl_alias=mdl_alias,
+                    caller_dir=caller_dir,
+                )
+            else:
+                module_name = override_name if override_name else module_name
+                module = create_jac_py_module(
+                    valid_mod_bundle,
+                    module_name,
+                    package_path,
+                    full_target,
+                )
+                codeobj = get_codeobj(
+                    full_target,
+                    module_name,
+                    valid_mod_bundle,
+                    cachable,
+                    caller_dir=caller_dir,
+                )
+                try:
+                    if not codeobj:
+                        raise ImportError(f"No bytecode found for {full_target}")
+                    with sys_path_context(caller_dir):
+                        exec(codeobj, module.__dict__)
+                except Exception as e:
+                    raise ImportError(f"Error importing {full_target}: {str(e)}")
+    unique_loaded_items = (
+        process_items(
+            module=module,
             items=items,
-            absorb=absorb,
-            mdl_alias=mdl_alias,
             caller_dir=caller_dir,
+            mod_bundle=valid_mod_bundle,
+            cachable=cachable,
+            lang=lng,
         )
-    else:
-        module_name = override_name if override_name else module_name
-
-        if os.path.isdir(path.splitext(full_target)[0]):
-            module = handle_directory(
-                module_name, path.splitext(full_target)[0], valid_mod_bundle
-            )
-            if items:
-                process_items(
-                    module,
-                    items,
-                    caller_dir,
-                    mod_bundle=valid_mod_bundle,
-                    cachable=cachable,
-                )
-        else:
-            module = create_jac_py_module(
-                valid_mod_bundle, module_name, package_path, full_target
-            )
-            codeobj = get_codeobj(
-                full_target=full_target,
-                module_name=module_name,
-                mod_bundle=valid_mod_bundle,
-                cachable=cachable,
-                caller_dir=caller_dir,
-            )
-            try:
-                if not codeobj:
-                    raise ImportError(f"No bytecode found for {full_target}")
-                with sys_path_context(caller_dir):
-                    exec(codeobj, module.__dict__)
-            except Exception as e:
-                print(f"Error importing {full_target}: {str(e)}")
-                return None
-    return module
+        if items
+        else []
+    )
+    return (module,) if absorb or not items else tuple(unique_loaded_items)
 
 
 def create_jac_py_module(
-    mod_bundle: Optional[Module | str],
+    mod_bundle: Optional[Module],
     module_name: str,
     package_path: str,
     full_target: str,
@@ -225,10 +247,18 @@ def create_jac_py_module(
     module.__dict__["__jac_mod_bundle__"] = mod_bundle
     if package_path:
         parts = package_path.split(".")
+        base_path = full_target.split(package_path.replace(".", path.sep))[0]
         for i in range(len(parts)):
             package_name = ".".join(parts[: i + 1])
             if package_name not in sys.modules:
-                sys.modules[package_name] = types.ModuleType(package_name)
+                full_mod_path = path.join(
+                    base_path, package_name.replace(".", path.sep)
+                )
+                handle_directory(
+                    module_name=package_name,
+                    full_mod_path=full_mod_path,
+                    mod_bundle=mod_bundle,
+                )
 
         setattr(sys.modules[package_path], module_name, module)
         sys.modules[f"{package_path}.{module_name}"] = module
@@ -253,12 +283,13 @@ def get_caller_dir(target: str, base_path: str, dir_path: str) -> str:
 def py_import(
     target: str,
     caller_dir: str,
-    items: Optional[dict[str, Union[str, bool]]] = None,
+    items: Optional[dict[str, Union[str, Optional[str]]]] = None,
     absorb: bool = False,
     mdl_alias: Optional[str] = None,
-) -> types.ModuleType:
+) -> tuple[types.ModuleType, ...]:
     """Import a Python module."""
     try:
+        loaded_items: list = []
         if target.startswith("."):
             target = target.lstrip(".")
             full_target = path.normpath(path.join(caller_dir, target))
@@ -279,19 +310,25 @@ def py_import(
 
         elif items:
             for name, alias in items.items():
+                if isinstance(alias, bool):
+                    alias = name
                 try:
-                    setattr(
-                        main_module,
-                        alias if isinstance(alias, str) else name,
-                        getattr(imported_module, name),
-                    )
-                except AttributeError as e:
-                    if hasattr(imported_module, "__path__"):
+                    item = getattr(imported_module, name)
+                    if item not in loaded_items:
                         setattr(
-                            main_module,
-                            alias if isinstance(alias, str) else name,
-                            importlib.import_module(f"{target}.{name}"),
+                            main_module, alias if isinstance(alias, str) else name, item
                         )
+                        loaded_items.append(item)
+                except AttributeError as e:
+                    if hasattr(imported_module, "__path__"):
+                        item = importlib.import_module(f"{target}.{name}")
+                        if item not in loaded_items:
+                            setattr(
+                                main_module,
+                                alias if isinstance(alias, str) else name,
+                                item,
+                            )
+                            loaded_items.append(item)
                     else:
                         raise e
 
@@ -301,7 +338,7 @@ def py_import(
                 mdl_alias if isinstance(mdl_alias, str) else target,
                 imported_module,
             )
-        return imported_module
+        return (imported_module, *loaded_items)
+
     except ImportError as e:
-        print(f"Failed to import module {target}")
         raise e