kopipasta 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

kopipasta/import_parser.py

@@ -12,7 +12,10 @@ _tsconfig_configs_cache: Dict[str, Tuple[Optional[str], Dict[str, List[str]]]] =
 
 # --- TypeScript Alias and Import Resolution ---
 
-def find_relevant_tsconfig_path(file_path_abs: str, project_root_abs: str) -> Optional[str]:
+
+def find_relevant_tsconfig_path(
+    file_path_abs: str, project_root_abs: str
+) -> Optional[str]:
     """
     Finds the most relevant tsconfig.json by searching upwards from the file's directory,
     stopping at project_root_abs.
@@ -21,17 +24,23 @@ def find_relevant_tsconfig_path(file_path_abs: str, project_root_abs: str) -> Op
     current_dir = os.path.dirname(os.path.normpath(file_path_abs))
     project_root_abs_norm = os.path.normpath(project_root_abs)
 
-    while current_dir.startswith(project_root_abs_norm) and len(current_dir) >= len(project_root_abs_norm):
+    while current_dir.startswith(project_root_abs_norm) and len(current_dir) >= len(
+        project_root_abs_norm
+    ):
         potential_tsconfig = os.path.join(current_dir, "tsconfig.json")
         if os.path.isfile(potential_tsconfig):
             return os.path.normpath(potential_tsconfig)
 
         try:
-            variant_tsconfigs = sorted([
-                f for f in os.listdir(current_dir)
-                if f.startswith("tsconfig.") and f.endswith(".json") and
-                   os.path.isfile(os.path.join(current_dir, f))
-            ])
+            variant_tsconfigs = sorted(
+                [
+                    f
+                    for f in os.listdir(current_dir)
+                    if f.startswith("tsconfig.")
+                    and f.endswith(".json")
+                    and os.path.isfile(os.path.join(current_dir, f))
+                ]
+            )
             if variant_tsconfigs:
                 return os.path.normpath(os.path.join(current_dir, variant_tsconfigs[0]))
         except OSError:
@@ -39,7 +48,7 @@ def find_relevant_tsconfig_path(file_path_abs: str, project_root_abs: str) -> Op
 
         if current_dir == project_root_abs_norm:
             break
-        
+
         parent_dir = os.path.dirname(current_dir)
         if parent_dir == current_dir:
             break
@@ -47,7 +56,9 @@ def find_relevant_tsconfig_path(file_path_abs: str, project_root_abs: str) -> Op
     return None
 
 
-def load_tsconfig_config(tsconfig_path_abs: str) -> Tuple[Optional[str], Dict[str, List[str]]]:
+def load_tsconfig_config(
+    tsconfig_path_abs: str,
+) -> Tuple[Optional[str], Dict[str, List[str]]]:
     """
     Loads baseUrl and paths from a specific tsconfig.json.
     Caches results.
@@ -59,21 +70,25 @@ def load_tsconfig_config(tsconfig_path_abs: str) -> Tuple[Optional[str], Dict[st
     if not os.path.isfile(tsconfig_path_abs):
         _tsconfig_configs_cache[tsconfig_path_abs] = (None, {})
         return None, {}
-        
+
     try:
-        with open(tsconfig_path_abs, 'r', encoding='utf-8') as f:
+        with open(tsconfig_path_abs, "r", encoding="utf-8") as f:
             content = f.read()
-            content = re.sub(r"//.*?\n", "\n", content) 
+            content = re.sub(r"//.*?\n", "\n", content)
             content = re.sub(r"/\*.*?\*/", "", content, flags=re.DOTALL)
             config = json.loads(content)
-        
+
         compiler_options = config.get("compilerOptions", {})
         tsconfig_dir = os.path.dirname(tsconfig_path_abs)
-        base_url_from_config = compiler_options.get("baseUrl", ".") 
-        abs_base_url = os.path.normpath(os.path.join(tsconfig_dir, base_url_from_config))
-        
+        base_url_from_config = compiler_options.get("baseUrl", ".")
+        abs_base_url = os.path.normpath(
+            os.path.join(tsconfig_dir, base_url_from_config)
+        )
+
         paths = compiler_options.get("paths", {})
-        processed_paths = {key: (val if isinstance(val, list) else [val]) for key, val in paths.items()}
+        processed_paths = {
+            key: (val if isinstance(val, list) else [val]) for key, val in paths.items()
+        }
 
         # print(f"DEBUG: Loaded config from {os.path.relpath(tsconfig_path_abs)}: effective abs_baseUrl='{abs_base_url}', {len(processed_paths)} path alias(es).")
         _tsconfig_configs_cache[tsconfig_path_abs] = (abs_base_url, processed_paths)
@@ -88,19 +103,21 @@ def _probe_ts_path_candidates(candidate_base_path_abs: str) -> Optional[str]:
     """
     Given a candidate base absolute path, tries to find a corresponding file.
     """
-    possible_extensions = ['.ts', '.tsx', '.js', '.jsx', '.json']
-    
+    possible_extensions = [".ts", ".tsx", ".js", ".jsx", ".json"]
+
     if os.path.isfile(candidate_base_path_abs):
         return candidate_base_path_abs
 
     stem, original_ext = os.path.splitext(candidate_base_path_abs)
-    base_for_ext_check = stem if original_ext.lower() in possible_extensions else candidate_base_path_abs
+    base_for_ext_check = (
+        stem if original_ext.lower() in possible_extensions else candidate_base_path_abs
+    )
 
     for ext in possible_extensions:
         path_with_ext = base_for_ext_check + ext
         if os.path.isfile(path_with_ext):
             return path_with_ext
-            
+
     if os.path.isdir(base_for_ext_check):
         for ext in possible_extensions:
             index_file_path = os.path.join(base_for_ext_check, "index" + ext)
@@ -110,10 +127,10 @@ def _probe_ts_path_candidates(candidate_base_path_abs: str) -> Optional[str]:
 
 
 def resolve_ts_import_path(
-    import_str: str, 
-    current_file_dir_abs: str, 
-    abs_base_url: Optional[str], 
-    alias_map: Dict[str, List[str]]
+    import_str: str,
+    current_file_dir_abs: str,
+    abs_base_url: Optional[str],
+    alias_map: Dict[str, List[str]],
 ) -> Optional[str]:
     """
     Resolves a TypeScript import string to an absolute file path.
@@ -125,26 +142,40 @@ def resolve_ts_import_path(
     for alias_pattern in sorted_alias_keys:
         alias_prefix_pattern = alias_pattern.replace("/*", "")
         if import_str.startswith(alias_prefix_pattern):
-            import_suffix = import_str[len(alias_prefix_pattern):]
+            import_suffix = import_str[len(alias_prefix_pattern) :]
             for mapping_path_template_list in alias_map[alias_pattern]:
-                for mapping_path_template in (mapping_path_template_list if isinstance(mapping_path_template_list, list) else [mapping_path_template_list]):
-                    if "/*" in alias_pattern :
-                        resolved_relative_to_base = mapping_path_template.replace("*", import_suffix, 1)
+                for mapping_path_template in (
+                    mapping_path_template_list
+                    if isinstance(mapping_path_template_list, list)
+                    else [mapping_path_template_list]
+                ):
+                    if "/*" in alias_pattern:
+                        resolved_relative_to_base = mapping_path_template.replace(
+                            "*", import_suffix, 1
+                        )
                     else:
                         resolved_relative_to_base = mapping_path_template
                     if abs_base_url:
-                        abs_candidate = os.path.normpath(os.path.join(abs_base_url, resolved_relative_to_base))
+                        abs_candidate = os.path.normpath(
+                            os.path.join(abs_base_url, resolved_relative_to_base)
+                        )
                         candidate_targets_abs.append(abs_candidate)
                     else:
-                        print(f"Warning: TS Alias '{alias_pattern}' used, but no abs_base_url for context of '{current_file_dir_abs}'.")
+                        print(
+                            f"Warning: TS Alias '{alias_pattern}' used, but no abs_base_url for context of '{current_file_dir_abs}'."
+                        )
             if candidate_targets_abs:
                 alias_matched_and_resolved = True
                 break
 
-    if not alias_matched_and_resolved and import_str.startswith('.'):
+    if not alias_matched_and_resolved and import_str.startswith("."):
         abs_candidate = os.path.normpath(os.path.join(current_file_dir_abs, import_str))
         candidate_targets_abs.append(abs_candidate)
-    elif not alias_matched_and_resolved and abs_base_url and not import_str.startswith('.'):
+    elif (
+        not alias_matched_and_resolved
+        and abs_base_url
+        and not import_str.startswith(".")
+    ):
         abs_candidate = os.path.normpath(os.path.join(abs_base_url, import_str))
         candidate_targets_abs.append(abs_candidate)
 
@@ -156,19 +187,19 @@ def resolve_ts_import_path(
 
 
 def parse_typescript_imports(
-    file_content: str, 
-    file_path_abs: str,
-    project_root_abs: str
+    file_content: str, file_path_abs: str, project_root_abs: str
 ) -> Set[str]:
     resolved_imports_abs_paths = set()
-    relevant_tsconfig_abs_path = find_relevant_tsconfig_path(file_path_abs, project_root_abs)
-    
+    relevant_tsconfig_abs_path = find_relevant_tsconfig_path(
+        file_path_abs, project_root_abs
+    )
+
     abs_base_url, alias_map = None, {}
     if relevant_tsconfig_abs_path:
         abs_base_url, alias_map = load_tsconfig_config(relevant_tsconfig_abs_path)
     else:
         # print(f"Warning: No tsconfig.json found for {os.path.relpath(file_path_abs, project_root_abs)}. Import resolution might be limited.")
-        abs_base_url = project_root_abs 
+        abs_base_url = project_root_abs
 
     import_regex = re.compile(
         r"""
@@ -178,31 +209,40 @@ def parse_typescript_imports(
         |require\s*\(\s*['"`]([^'"\n`]+?)['"`]\s*\)
         |import\s*\(\s*['"`]([^'"\n`]+?)['"`]\s*\)
         """,
-        re.VERBOSE | re.MULTILINE
+        re.VERBOSE | re.MULTILINE,
     )
-    
+
     current_file_dir_abs = os.path.dirname(file_path_abs)
 
     for match in import_regex.finditer(file_content):
         import_str_candidate = next((g for g in match.groups() if g is not None), None)
         if import_str_candidate:
             is_likely_external = (
-                not import_str_candidate.startswith(('.', '/')) and
-                not any(import_str_candidate.startswith(alias_pattern.replace("/*", "")) for alias_pattern in alias_map) and
-                not (abs_base_url and os.path.exists(os.path.join(abs_base_url, import_str_candidate))) and
-                (import_str_candidate.count('/') == 0 or (import_str_candidate.startswith('@') and import_str_candidate.count('/') == 1)) and
-                '.' not in import_str_candidate.split('/')[0]
+                not import_str_candidate.startswith((".", "/"))
+                and not any(
+                    import_str_candidate.startswith(alias_pattern.replace("/*", ""))
+                    for alias_pattern in alias_map
+                )
+                and not (
+                    abs_base_url
+                    and os.path.exists(os.path.join(abs_base_url, import_str_candidate))
+                )
+                and (
+                    import_str_candidate.count("/") == 0
+                    or (
+                        import_str_candidate.startswith("@")
+                        and import_str_candidate.count("/") == 1
+                    )
+                )
+                and "." not in import_str_candidate.split("/")[0]
             )
             if is_likely_external:
                 continue
 
             resolved_abs_path = resolve_ts_import_path(
-                import_str_candidate, 
-                current_file_dir_abs, 
-                abs_base_url, 
-                alias_map
+                import_str_candidate, current_file_dir_abs, abs_base_url, alias_map
             )
-            
+
             if resolved_abs_path:
                 norm_resolved_path = os.path.normpath(resolved_abs_path)
                 if norm_resolved_path.startswith(os.path.normpath(project_root_abs)):
@@ -212,11 +252,12 @@ def parse_typescript_imports(
 
 # --- Python Import Resolution ---
 
+
 def resolve_python_import(
-    module_name_parts: List[str], 
-    current_file_dir_abs: str, 
-    project_root_abs: str, 
-    level: int
+    module_name_parts: List[str],
+    current_file_dir_abs: str,
+    project_root_abs: str,
+    level: int,
 ) -> Optional[str]:
     base_path_to_search = ""
     if level > 0:
@@ -228,11 +269,11 @@ def resolve_python_import(
 
     candidate_rel_path = os.path.join(*module_name_parts)
     potential_abs_path = os.path.join(base_path_to_search, candidate_rel_path)
-    
+
     py_file = potential_abs_path + ".py"
     if os.path.isfile(py_file):
         return os.path.normpath(py_file)
-    
+
     init_file = os.path.join(potential_abs_path, "__init__.py")
     if os.path.isdir(potential_abs_path) and os.path.isfile(init_file):
         return os.path.normpath(init_file)
@@ -250,10 +291,12 @@ def resolve_python_import(
     return None
 
 
-def parse_python_imports(file_content: str, file_path_abs: str, project_root_abs: str) -> Set[str]:
+def parse_python_imports(
+    file_content: str, file_path_abs: str, project_root_abs: str
+) -> Set[str]:
     resolved_imports = set()
     current_file_dir_abs = os.path.dirname(file_path_abs)
-    
+
     try:
         tree = ast.parse(file_content, filename=file_path_abs)
     except SyntaxError:
@@ -263,22 +306,51 @@ def parse_python_imports(file_content: str, file_path_abs: str, project_root_abs
     for node in ast.walk(tree):
         if isinstance(node, ast.Import):
             for alias in node.names:
-                module_parts = alias.name.split('.')
-                resolved = resolve_python_import(module_parts, current_file_dir_abs, project_root_abs, level=0)
-                if resolved and os.path.exists(resolved) and os.path.normpath(resolved).startswith(os.path.normpath(project_root_abs)):
+                module_parts = alias.name.split(".")
+                resolved = resolve_python_import(
+                    module_parts, current_file_dir_abs, project_root_abs, level=0
+                )
+                if (
+                    resolved
+                    and os.path.exists(resolved)
+                    and os.path.normpath(resolved).startswith(
+                        os.path.normpath(project_root_abs)
+                    )
+                ):
                     resolved_imports.add(os.path.normpath(resolved))
         elif isinstance(node, ast.ImportFrom):
             level_to_resolve = node.level
             if node.module:
-                module_parts = node.module.split('.')
-                resolved = resolve_python_import(module_parts, current_file_dir_abs, project_root_abs, level_to_resolve)
-                if resolved and os.path.exists(resolved) and os.path.normpath(resolved).startswith(os.path.normpath(project_root_abs)):
+                module_parts = node.module.split(".")
+                resolved = resolve_python_import(
+                    module_parts,
+                    current_file_dir_abs,
+                    project_root_abs,
+                    level_to_resolve,
+                )
+                if (
+                    resolved
+                    and os.path.exists(resolved)
+                    and os.path.normpath(resolved).startswith(
+                        os.path.normpath(project_root_abs)
+                    )
+                ):
                     resolved_imports.add(os.path.normpath(resolved))
             else:
                 for alias in node.names:
-                    item_name_parts = alias.name.split('.')
-                    resolved = resolve_python_import(item_name_parts, current_file_dir_abs, project_root_abs, level=level_to_resolve)
-                    if resolved and os.path.exists(resolved) and os.path.normpath(resolved).startswith(os.path.normpath(project_root_abs)):
+                    item_name_parts = alias.name.split(".")
+                    resolved = resolve_python_import(
+                        item_name_parts,
+                        current_file_dir_abs,
+                        project_root_abs,
+                        level=level_to_resolve,
+                    )
+                    if (
+                        resolved
+                        and os.path.exists(resolved)
+                        and os.path.normpath(resolved).startswith(
+                            os.path.normpath(project_root_abs)
+                        )
+                    ):
                         resolved_imports.add(os.path.normpath(resolved))
     return resolved_imports
-