jaclang 0.7.26__py3-none-any.whl → 0.7.28__py3-none-any.whl

jaclang/cli/cli.py

@@ -307,6 +307,7 @@ def enter(
 @cmd_registry.register
 def test(
     filepath: str,
+    test_name: str = "",
     filter: str = "",
     xit: bool = False,
     maxfail: int = None,  # type:ignore
@@ -316,6 +317,7 @@ def test(
     """Run the test suite in the specified .jac file.
 
     :param filepath: Path/to/file.jac
+    :param test_name: Run a specific test.
     :param filter: Filter the files using Unix shell style conventions.
     :param xit(exit): Stop(exit) running tests as soon as finds an error.
     :param maxfail: Stop running tests after n failures.
@@ -328,6 +330,7 @@ def test(
 
     failcount = Jac.run_test(
         filepath=filepath,
+        func_name=("test_" + test_name) if test_name else None,
         filter=filter,
         xit=xit,
         maxfail=maxfail,

jaclang/compiler/absyntree.py

@@ -30,6 +30,7 @@ from jaclang.compiler.constant import (
     SymbolType,
 )
 from jaclang.compiler.constant import DELIM_MAP, SymbolAccess, Tokens as Tok
+from jaclang.compiler.py_info import PyInfo
 from jaclang.compiler.semtable import SemRegistry
 from jaclang.utils.treeprinter import dotgen_ast_tree, print_ast_tree
 
@@ -636,11 +637,10 @@ class Module(AstDocNode):
         self.impl_mod: list[Module] = []
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
-        self.py_mod_dep_map: dict[str, str] = {}
-        self.py_raise_map: dict[str, str] = {}
         self.registry = registry
         self.terminals: list[Token] = terminals
-        self.is_raised_from_py: bool = False
+        self.py_info: PyInfo = PyInfo()
+
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -693,6 +693,21 @@ class Module(AstDocNode):
         super().unparse()
         return self.format()
 
+    @staticmethod
+    def get_href_path(node: AstNode) -> str:
+        """Return the full path of the module that contains this node."""
+        parent = node.find_parent_of_type(Module)
+        mod_list: list[Module | Architype] = []
+        if isinstance(node, (Module, Architype)):
+            mod_list.append(node)
+        while parent is not None:
+            mod_list.append(parent)
+            parent = parent.find_parent_of_type(Module)
+        mod_list.reverse()
+        return ".".join(
+            p.name if isinstance(p, Module) else p.name.sym_name for p in mod_list
+        )
+
 
 class GlobalVars(ElementStmt, AstAccessNode):
     """GlobalVars node type for Jac Ast."""

jaclang/compiler/passes/main/__init__.py

@@ -2,9 +2,9 @@
 
 from .sub_node_tab_pass import SubNodeTabPass
 from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
+from .def_use_pass import DefUsePass  # noqa: I100
 from .import_pass import JacImportPass, PyImportPass  # noqa: I100
 from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
-from .def_use_pass import DefUsePass  # noqa: I100
 from .pyout_pass import PyOutPass  # noqa: I100
 from .pyast_load_pass import PyastBuildPass  # type: ignore # noqa: I100
 from .pyast_gen_pass import PyastGenPass  # noqa: I100

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -45,7 +45,7 @@ class AccessCheckPass(Pass):
             settings.lsp_debug
             and isinstance(node, ast.NameAtom)
             and not node.sym
-            and not node.parent_of_type(ast.Module).is_raised_from_py
+            and not node.parent_of_type(ast.Module).py_info.is_raised_from_py
             and not (
                 node.sym_name == "py"
                 and node.parent

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -10,6 +10,7 @@ import re
 from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import Constants, Tokens
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
 from jaclang.settings import settings
@@ -76,35 +77,6 @@ class FuseTypeInfoPass(Pass):
         if typ_sym_table != self.ir.sym_tab:
             node.name_spec.type_sym_tab = typ_sym_table
 
-    def __collect_python_dependencies(self, node: ast.AstNode) -> None:
-        assert isinstance(node, ast.AstSymbolNode)
-        assert isinstance(self.ir, ast.Module)
-
-        mypy_node = node.gen.mypy_ast[0]
-
-        if isinstance(mypy_node, MypyNodes.RefExpr) and mypy_node.node:
-            node_full_name = mypy_node.node.fullname
-            if "." in node_full_name:
-                mod_name = node_full_name[: node_full_name.rindex(".")]
-            else:
-                mod_name = node_full_name
-
-            if mod_name not in self.ir.py_mod_dep_map:
-                self.__debug_print(
-                    f"Can't find a python file associated with {type(node)}::{node.loc}"
-                )
-                return
-
-            mode_path = self.ir.py_mod_dep_map[mod_name]
-            if mode_path.endswith(".jac"):
-                return
-
-            self.ir.py_raise_map[mod_name] = mode_path
-        else:
-            self.__debug_print(
-                f"Collect python dependencies is not supported in {type(node)}::{node.loc}"
-            )
-
     @staticmethod
     def __handle_node(
         func: Callable[[FuseTypeInfoPass, T], None]
@@ -126,7 +98,6 @@ class FuseTypeInfoPass(Pass):
                 if len(node.gen.mypy_ast) == 1:
                     func(self, node)
                     self.__set_type_sym_table_link(node)
-                    self.__collect_python_dependencies(node)
 
                 # Jac node has multiple mypy nodes linked to it
                 elif len(node.gen.mypy_ast) > 1:
@@ -150,7 +121,6 @@ class FuseTypeInfoPass(Pass):
                         )
                         func(self, node)
                         self.__set_type_sym_table_link(node)
-                        self.__collect_python_dependencies(node)
 
                 # Special handing for BuiltinType
                 elif isinstance(node, ast.BuiltinType):
@@ -266,6 +236,43 @@ class FuseTypeInfoPass(Pass):
         if len(node.gen.mypy_ast) == 0:
             return
 
+        # No need to run this handling in case of a previous type
+        # was set during the pass, if not then we hope that the
+        # mypy node has a type associated to it
+        if node.expr_type != "NoType":
+            return
+
+        # Check if the expression is a data spatial expression
+        # Support disconnectOp
+        if isinstance(node, ast.BinaryExpr):
+            if isinstance(node.op, ast.DisconnectOp):
+                node.expr_type = "builtins.bool"
+                return
+
+            # Support spwan and connectOp
+            elif (
+                isinstance(node.op, ast.ConnectOp)
+                or node.op.name == Tokens.KW_SPAWN.value
+            ):
+                if node.gen.mypy_ast[-1] in self.node_type_hash:
+                    node.expr_type = (
+                        self.__call_type_handler(
+                            self.node_type_hash[node.gen.mypy_ast[-1]]
+                        )
+                        or node.expr_type
+                    )
+                return
+
+        if isinstance(node, ast.EdgeRefTrailer) and any(
+            isinstance(k, ast.FilterCompr) for k in node.kid
+        ):
+            if node.gen.mypy_ast[-1] in self.node_type_hash:
+                node.expr_type = (
+                    self.__call_type_handler(self.node_type_hash[node.gen.mypy_ast[-1]])
+                    or node.expr_type
+                )
+            return
+
         # If the corrosponding mypy ast node type has stored here, get the values.
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
@@ -427,7 +434,14 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None:
         """Pass handler for SpecialVarRef nodes."""
-        return self.enter_name(node)
+        if node.py_resolve_name() == Constants.ROOT:
+            if node.gen.mypy_ast[-1] in self.node_type_hash:
+                node.name_spec.expr_type = (
+                    self.__call_type_handler(self.node_type_hash[node.gen.mypy_ast[-1]])
+                    or node.name_spec.expr_type
+                )
+        else:
+            self.enter_name(node)
 
     @__handle_node
     def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None:
@@ -491,7 +505,7 @@ class FuseTypeInfoPass(Pass):
         self, mypy_type: MypyTypes.Overloaded
     ) -> Optional[str]:
         """Get type info from mypy type Overloaded."""
-        return self.__call_type_handler(mypy_type.items[0])
+        return self.__call_type_handler(mypy_type.items[-1])
 
     def get_type_from_none_type(self, mypy_type: MypyTypes.NoneType) -> Optional[str]:
         """Get type info from mypy type NoneType."""
@@ -509,6 +523,12 @@ class FuseTypeInfoPass(Pass):
         """Get type info from mypy type TypeType."""
         return str(mypy_type.item)
 
+    def get_type_from_type_var_type(
+        self, mypy_type: MypyTypes.TypeVarType
+    ) -> Optional[str]:
+        """Get type info from mypy type TypeType."""
+        return str(mypy_type.name)
+
     def exit_assignment(self, node: ast.Assignment) -> None:
         """Add new symbols in the symbol table in case of self."""
         # This will fix adding new items to the class through self
@@ -590,6 +610,7 @@ class FuseTypeInfoPass(Pass):
                     # right index slice is a range then it's type is the same as left
                     if right.is_range:
                         right.expr_type = left.expr_type
+                        right.parent_of_type(ast.AtomTrailer).expr_type = node_type
                         continue
 
                 # left type is a dictionary
@@ -603,6 +624,7 @@ class FuseTypeInfoPass(Pass):
                     continue
 
                 right.expr_type = node_type
+                right.parent_of_type(ast.AtomTrailer).expr_type = node_type
 
                 # Getting the correct symbol table and link it
                 type_symtab: Optional[SymbolTable] = self.ir.sym_tab
@@ -621,6 +643,13 @@ class FuseTypeInfoPass(Pass):
                 right.type_sym_tab = type_symtab
 
             else:
+                # Fix the symbolTable linking in case of type annotations
+                if left.type_sym_tab is None and isinstance(node.parent, ast.SubTag):
+                    assert isinstance(left, ast.AstSymbolNode)
+                    left.name_spec.type_sym_tab = self.ir.sym_tab.find_scope(
+                        left.sym_name
+                    )
+
                 if left.type_sym_tab:
                     right.name_spec.sym = left.type_sym_tab.lookup(right.sym_name)
                     if right.name_spec.sym:

jaclang/compiler/passes/main/import_pass.py

@@ -12,8 +12,11 @@ from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import SymbolType
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.passes.main import SubNodeTabPass, SymTabBuildPass
+from jaclang.compiler.passes.main import DefUsePass, SubNodeTabPass, SymTabBuildPass
+from jaclang.compiler.passes.main.sym_tab_build_pass import PyInspectSymTabBuildPass
+from jaclang.compiler.symtable import Symbol, SymbolTable
 from jaclang.settings import settings
 from jaclang.utils.log import logging
 
@@ -198,19 +201,20 @@ class JacImportPass(Pass):
 class PyImportPass(JacImportPass):
     """Jac statically imports Python modules."""
 
+    def __debug_print(self, msg: str) -> None:
+        if settings.py_import_pass_debug:
+            self.log_info("[PyImportPass] " + msg)
+
     def before_pass(self) -> None:
         """Only run pass if settings are set to raise python."""
+        self.import_from_build_list: list[tuple[ast.Import, ast.Module]] = []
         super().before_pass()
         self.__load_builtins()
 
-    def __get_current_module(self, node: ast.AstNode) -> str:
-        parent = node.find_parent_of_type(ast.Module)
-        mod_list = []
-        while parent is not None:
-            mod_list.append(parent)
-            parent = parent.find_parent_of_type(ast.Module)
-        mod_list.reverse()
-        return ".".join(p.name for p in mod_list)
+    def after_pass(self) -> None:
+        """Build symbol tables for import from nodes."""
+        self.__import_from_symbol_table_build()
+        return super().after_pass()
 
     def process_import(self, i: ast.ModulePath) -> None:
         """Process an import."""
@@ -218,87 +222,273 @@ class PyImportPass(JacImportPass):
         # This won't work with py imports as this will fail to import stuff in form of
         #      from a import b
         #      from a import (c, d, e)
-        # Solution to that is to get the import node and check the from loc then
+        # Solution to that is to get the import node and check the from loc `then`
         # handle it based on if there a from loc or not
         imp_node = i.parent_of_type(ast.Import)
+
         if imp_node.is_py and not i.sub_module:
             if imp_node.from_loc:
-                for j in imp_node.items.items:
-                    assert isinstance(j, ast.ModuleItem)
-                    mod_path = f"{imp_node.from_loc.dot_path_str}.{j.name.sym_name}"
-                    self.import_py_module(
-                        parent_node=j,
-                        mod_path=mod_path,
-                        imported_mod_name=(
-                            j.name.sym_name if not j.alias else j.alias.sym_name
-                        ),
-                    )
+                msg = "Processing import from node at href="
+                msg += ast.Module.get_href_path(imp_node)
+                msg += f' path="{imp_node.loc.mod_path}, {imp_node.loc}"'
+                self.__debug_print(msg)
+                self.__process_import_from(imp_node)
+            else:
+                msg = "Processing import node at href="
+                msg += ast.Module.get_href_path(imp_node)
+                msg += f' path="{imp_node.loc.mod_path}, {imp_node.loc}"'
+                self.__debug_print(msg)
+                self.__process_import(imp_node)
+
+    def __process_import_from(self, imp_node: ast.Import) -> None:
+        """Process imports in the form of `from X import I`."""
+        assert isinstance(self.ir, ast.Module)
+        assert isinstance(imp_node.from_loc, ast.ModulePath)
+
+        self.__debug_print(f"\tTrying to import {imp_node.from_loc.dot_path_str}")
+
+        # Attempt to import the Python module X and process it
+        imported_mod = self.__import_py_module(
+            parent_node_path=ast.Module.get_href_path(imp_node),
+            mod_path=imp_node.from_loc.dot_path_str,
+        )
+
+        if imported_mod:
+            # Cyclic imports will happen in case of import sys
+            # sys stub file imports sys module which means that we need
+            # to import sys stub file again in the sys stub file and so on
+            # This can be detected by iterating over all the parents and make sure
+            # that the parent is in another file than the imported module
+            if self.__check_cyclic_imports(imp_node, imported_mod):
+                self.__debug_print(
+                    f"\tCycled imports is found at {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+
+            if imported_mod.name == "builtins":
+                self.__debug_print(
+                    f"\tIgnoring attaching builtins {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+
+            self.__debug_print(
+                f"\tAttaching {imported_mod.name} into {ast.Module.get_href_path(imp_node)}"
+            )
+            msg = f"\tRegistering module:{imported_mod.name} to "
+            msg += f"import_from handling with {imp_node.loc.mod_path}:{imp_node.loc}"
+            self.__debug_print(msg)
+
+            self.attach_mod_to_node(imp_node.from_loc, imported_mod)
+            self.import_from_build_list.append((imp_node, imported_mod))
+            if imported_mod._sym_tab is None:
+                self.__debug_print(
+                    f"\tBuilding symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
             else:
-                for j in imp_node.items.items:
-                    assert isinstance(j, ast.ModulePath)
-                    self.import_py_module(
-                        parent_node=j,
-                        mod_path=j.dot_path_str,
-                        imported_mod_name=(
-                            j.dot_path_str.replace(".", "")
-                            if not j.alias
-                            else j.alias.sym_name
-                        ),
+                self.__debug_print(
+                    f"\tRefreshing symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
+            PyInspectSymTabBuildPass(input_ir=imported_mod, prior=self)
+            DefUsePass(input_ir=imported_mod, prior=self)
+
+    def __import_from_symbol_table_build(self) -> None:
+        """Build symbol tables for the imported python modules."""
+        is_symbol_tabled_refreshed: list[str] = []
+        self.import_from_build_list.reverse()
+        for imp_node, imported_mod in self.import_from_build_list:
+            # Need to build the symbol tables again to make sure that the
+            # complete symbol table is built.
+            #
+            # Complete symbol tables won't be built in case of another
+            # import from statements in the imported modules.
+            #
+            # A solution was to only build the symbol table here after the
+            # full ast is raised but this will cause an issue with symboltable
+            # building with normal imports
+            #
+            # TODO: Change normal imports to call symbolTable here too
+
+            if imported_mod.loc.mod_path not in is_symbol_tabled_refreshed:
+                self.__debug_print(
+                    f"Refreshing symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
+                PyInspectSymTabBuildPass(input_ir=imported_mod, prior=self)
+                DefUsePass(input_ir=imported_mod, prior=self)
+                is_symbol_tabled_refreshed.append(imported_mod.loc.mod_path)
+
+            sym_tab = imported_mod.sym_tab
+            parent_sym_tab = imp_node.parent_of_type(ast.Module).sym_tab
+
+            if imp_node.is_absorb:
+                for symbol in sym_tab.tab.values():
+                    if symbol.sym_type == SymbolType.MODULE:
+                        continue
+                    self.__import_from_sym_table_add_symbols(symbol, parent_sym_tab)
+            else:
+                for i in imp_node.items.items:
+                    assert isinstance(i, ast.ModuleItem)
+                    needed_sym = sym_tab.lookup(i.name.sym_name)
+
+                    if needed_sym and needed_sym.defn[0].parent:
+                        self.__import_from_sym_table_add_symbols(
+                            needed_sym, parent_sym_tab
+                        )
+                    else:
+                        self.__debug_print(
+                            f"Can't find a symbol matching {i.name.sym_name} in {sym_tab.name}"
+                        )
+
+    def __import_from_sym_table_add_symbols(
+        self, sym: Symbol, sym_table: SymbolTable
+    ) -> None:
+        self.__debug_print(
+            f"\tAdding {sym.sym_type}:{sym.sym_name} into {sym_table.name}"
+        )
+        assert isinstance(sym.defn[0], ast.AstSymbolNode)
+        sym_table.def_insert(
+            node=sym.defn[0],
+            access_spec=sym.access,
+            force_overwrite=True,
+        )
+
+        if sym.fetch_sym_tab:
+            msg = f"\tAdding SymbolTable:{sym.fetch_sym_tab.name} into "
+            msg += f"SymbolTable:{sym_table.name} kids"
+            self.__debug_print(msg)
+            sym_table.kid.append(sym.fetch_sym_tab)
+        elif sym.sym_type not in (SymbolType.VAR, SymbolType.MOD_VAR):
+            raise AssertionError(
+                f"Unexpected symbol type '{sym.sym_type}' that doesn't have a symbl table"
+            )
+
+    def __process_import(self, imp_node: ast.Import) -> None:
+        """Process the imports in form of `import X`."""
+        # Expected that each ImportStatement will import one item
+        # In case of this assertion fired then we need to revisit this item
+        assert len(imp_node.items.items) == 1
+        imported_item = imp_node.items.items[0]
+        assert isinstance(imported_item, ast.ModulePath)
+
+        self.__debug_print(f"\tTrying to import {imported_item.dot_path_str}")
+        imported_mod = self.__import_py_module(
+            parent_node_path=ast.Module.get_href_path(imported_item),
+            mod_path=imported_item.dot_path_str,
+            imported_mod_name=(
+                # TODO: Check this replace
+                imported_item.dot_path_str.replace(".", "")
+                if not imported_item.alias
+                else imported_item.alias.sym_name
+            ),
+        )
+        if imported_mod:
+            if self.__check_cyclic_imports(imp_node, imported_mod):
+                self.__debug_print(
+                    f"\tCycled imports is found at {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+            elif imported_mod.name == "builtins":
+                self.__debug_print(
+                    f"\tIgnoring attaching builtins {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+
+            self.__debug_print(
+                f"\tAttaching {imported_mod.name} into {ast.Module.get_href_path(imp_node)}"
+            )
+            self.attach_mod_to_node(imported_item, imported_mod)
+
+            if imp_node.is_absorb:
+                msg = f"\tRegistering module:{imported_mod.name} to "
+                msg += f"import_from (import all) handling with {imp_node.loc.mod_path}:{imp_node.loc}"
+                self.__debug_print(msg)
+
+                self.import_from_build_list.append((imp_node, imported_mod))
+                if imported_mod._sym_tab is None:
+                    self.__debug_print(
+                        f"\tBuilding symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                    )
+                else:
+                    self.__debug_print(
+                        f"\tRefreshing symbol table for module:{ast.Module.get_href_path(imported_mod)}"
                     )
+                PyInspectSymTabBuildPass(input_ir=imported_mod, prior=self)
+                DefUsePass(input_ir=imported_mod, prior=self)
+
+            else:
+                self.__debug_print(
+                    f"\tBuilding symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
+                SymTabBuildPass(input_ir=imported_mod, prior=self)
 
-    def import_py_module(
+    def __import_py_module(
         self,
-        parent_node: ast.ModulePath | ast.ModuleItem,
-        imported_mod_name: str,
+        parent_node_path: str,
         mod_path: str,
+        imported_mod_name: Optional[str] = None,
     ) -> Optional[ast.Module]:
-        """Import a module."""
+        """Import a python module."""
         from jaclang.compiler.passes.main import PyastBuildPass
 
         assert isinstance(self.ir, ast.Module)
 
-        python_raise_map = self.ir.py_raise_map
-        file_to_raise = None
+        python_raise_map = self.ir.py_info.py_raise_map
+        file_to_raise: Optional[str] = None
 
         if mod_path in python_raise_map:
             file_to_raise = python_raise_map[mod_path]
         else:
-            resolved_mod_path = (
-                f"{self.__get_current_module(parent_node)}.{imported_mod_name}"
-            )
-            assert isinstance(self.ir, ast.Module)
+            # TODO: Is it fine to use imported_mod_name or get it from mod_path?
+            resolved_mod_path = f"{parent_node_path}.{mod_path}"
+            resolved_mod_path = resolved_mod_path.replace("..", ".")
             resolved_mod_path = resolved_mod_path.replace(f"{self.ir.name}.", "")
             file_to_raise = python_raise_map.get(resolved_mod_path)
 
         if file_to_raise is None:
+            self.__debug_print("\tNo file is found to do the import")
             return None
 
+        self.__debug_print(f"\tFile used to do the import is {file_to_raise}")
+
         try:
-            if file_to_raise not in {None, "built-in", "frozen"}:
-                if file_to_raise in self.import_table:
-                    return self.import_table[file_to_raise]
-
-                with open(file_to_raise, "r", encoding="utf-8") as f:
-                    file_source = f.read()
-                    mod = PyastBuildPass(
-                        input_ir=ast.PythonModuleAst(
-                            py_ast.parse(file_source),
-                            orig_src=ast.JacSource(file_source, file_to_raise),
-                        ),
-                    ).ir
-                    SubNodeTabPass(input_ir=mod, prior=self)
-                if mod:
-                    mod.name = imported_mod_name
-                    self.import_table[file_to_raise] = mod
-                    self.attach_mod_to_node(parent_node, mod)
-                    SymTabBuildPass(input_ir=mod, prior=self)
-                    return mod
-                else:
-                    raise self.ice(f"Failed to import python module {mod_path}")
+            if file_to_raise in {None, "built-in", "frozen"}:
+                return None
+
+            if file_to_raise in self.import_table:
+                self.__debug_print(
+                    f"\t{file_to_raise} was raised before, getting it from cache"
+                )
+                return self.import_table[file_to_raise]
+
+            with open(file_to_raise, "r", encoding="utf-8") as f:
+                file_source = f.read()
+                mod = PyastBuildPass(
+                    input_ir=ast.PythonModuleAst(
+                        py_ast.parse(file_source),
+                        orig_src=ast.JacSource(file_source, file_to_raise),
+                    ),
+                ).ir
+                SubNodeTabPass(input_ir=mod, prior=self)
+
+            if mod:
+                mod.name = imported_mod_name if imported_mod_name else mod.name
+                if mod.name == "__init__":
+                    mod_name = mod.loc.mod_path.split("/")[-2]
+                    self.__debug_print(
+                        f"\tRaised the __init__ file and rename the mod to be {mod_name}"
+                    )
+                    mod.name = mod_name
+                self.import_table[file_to_raise] = mod
+                mod.py_info.is_raised_from_py = True
+                self.__debug_print(
+                    f"\t{file_to_raise} is raised, adding it to the cache"
+                )
+                return mod
+            else:
+                raise self.ice(f"\tFailed to import python module {mod_path}")
+
         except Exception as e:
-            self.error(f"Failed to import python module {mod_path}")
+            self.error(f"\tFailed to import python module {mod_path}")
             raise e
-        return None
 
     def __load_builtins(self) -> None:
         """Pyraise builtins to help with builtins auto complete."""
@@ -330,3 +520,34 @@ class PyImportPass(JacImportPass):
     def annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         return None
+
+    def __handle_different_site_packages(self, mod_path: str) -> str:
+        if "site-packages" in mod_path:
+            mod_path = mod_path[mod_path.index("site-packages") :]
+        return mod_path
+
+    def __check_cyclic_imports(
+        self, imp_node: ast.AstNode, imported_module: ast.Module
+    ) -> bool:
+        """Check cyclic imports that might happen."""
+        # Example of cyclic imports is import os
+        # In the os stub file it imports the real os module which will cause os
+        # stub to be raised again and so on
+        # Another example is numpy. numpy init file imports multidim array file
+        # which imports again more items from numpy and so on.
+        imp_node_file = self.__handle_different_site_packages(imp_node.loc.mod_path)
+        imported_module_file = self.__handle_different_site_packages(
+            imported_module.loc.mod_path
+        )
+        if imp_node_file == imported_module_file:
+            return True
+
+        parent: Optional[ast.AstNode] = imp_node.parent
+        while parent is not None:
+            parent_file = self.__handle_different_site_packages(parent.loc.mod_path)
+            if parent_file == imported_module_file:
+                return True
+            else:
+                parent = parent.find_parent_of_type(ast.Module)
+
+        return False