init

.venv/lib/python3.8/site-packages/isort/place.py

@@ -0,0 +1,145 @@
+"""Contains all logic related to placing an import within a certain section."""
+import importlib
+from fnmatch import fnmatch
+from functools import lru_cache
+from pathlib import Path
+from typing import FrozenSet, Iterable, Optional, Tuple
+
+from isort import sections
+from isort.settings import DEFAULT_CONFIG, Config
+from isort.utils import exists_case_sensitive
+
+LOCAL = "LOCALFOLDER"
+
+
+def module(name: str, config: Config = DEFAULT_CONFIG) -> str:
+    """Returns the section placement for the given module name."""
+    return module_with_reason(name, config)[0]
+
+
+@lru_cache(maxsize=1000)
+def module_with_reason(name: str, config: Config = DEFAULT_CONFIG) -> Tuple[str, str]:
+    """Returns the section placement for the given module name alongside the reasoning."""
+    return (
+        _forced_separate(name, config)
+        or _local(name, config)
+        or _known_pattern(name, config)
+        or _src_path(name, config)
+        or (config.default_section, "Default option in Config or universal default.")
+    )
+
+
+def _forced_separate(name: str, config: Config) -> Optional[Tuple[str, str]]:
+    for forced_separate in config.forced_separate:
+        # Ensure all forced_separate patterns will match to end of string
+        path_glob = forced_separate
+        if not forced_separate.endswith("*"):
+            path_glob = "%s*" % forced_separate
+
+        if fnmatch(name, path_glob) or fnmatch(name, "." + path_glob):
+            return (forced_separate, f"Matched forced_separate ({forced_separate}) config value.")
+
+    return None
+
+
+def _local(name: str, config: Config) -> Optional[Tuple[str, str]]:
+    if name.startswith("."):
+        return (LOCAL, "Module name started with a dot.")
+
+    return None
+
+
+def _known_pattern(name: str, config: Config) -> Optional[Tuple[str, str]]:
+    parts = name.split(".")
+    module_names_to_check = (".".join(parts[:first_k]) for first_k in range(len(parts), 0, -1))
+    for module_name_to_check in module_names_to_check:
+        for pattern, placement in config.known_patterns:
+            if placement in config.sections and pattern.match(module_name_to_check):
+                return (placement, f"Matched configured known pattern {pattern}")
+
+    return None
+
+
+def _src_path(
+    name: str,
+    config: Config,
+    src_paths: Optional[Iterable[Path]] = None,
+    prefix: Tuple[str, ...] = (),
+) -> Optional[Tuple[str, str]]:
+    if src_paths is None:
+        src_paths = config.src_paths
+
+    root_module_name, *nested_module = name.split(".", 1)
+    new_prefix = prefix + (root_module_name,)
+    namespace = ".".join(new_prefix)
+
+    for src_path in src_paths:
+        module_path = (src_path / root_module_name).resolve()
+        if not prefix and not module_path.is_dir() and src_path.name == root_module_name:
+            module_path = src_path.resolve()
+        if nested_module and (
+            namespace in config.namespace_packages
+            or (
+                config.auto_identify_namespace_packages
+                and _is_namespace_package(module_path, config.supported_extensions)
+            )
+        ):
+            return _src_path(nested_module[0], config, (module_path,), new_prefix)
+        if (
+            _is_module(module_path)
+            or _is_package(module_path)
+            or _src_path_is_module(src_path, root_module_name)
+        ):
+            return (sections.FIRSTPARTY, f"Found in one of the configured src_paths: {src_path}.")
+
+    return None
+
+
+def _is_module(path: Path) -> bool:
+    return (
+        exists_case_sensitive(str(path.with_suffix(".py")))
+        or any(
+            exists_case_sensitive(str(path.with_suffix(ext_suffix)))
+            for ext_suffix in importlib.machinery.EXTENSION_SUFFIXES
+        )
+        or exists_case_sensitive(str(path / "__init__.py"))
+    )
+
+
+def _is_package(path: Path) -> bool:
+    return exists_case_sensitive(str(path)) and path.is_dir()
+
+
+def _is_namespace_package(path: Path, src_extensions: FrozenSet[str]) -> bool:
+    if not _is_package(path):
+        return False
+
+    init_file = path / "__init__.py"
+    if not init_file.exists():
+        filenames = [
+            filepath
+            for filepath in path.iterdir()
+            if filepath.suffix.lstrip(".") in src_extensions
+            or filepath.name.lower() in ("setup.cfg", "pyproject.toml")
+        ]
+        if filenames:
+            return False
+    else:
+        with init_file.open("rb") as open_init_file:
+            file_start = open_init_file.read(4096)
+            if (
+                b"__import__('pkg_resources').declare_namespace(__name__)" not in file_start
+                and b'__import__("pkg_resources").declare_namespace(__name__)' not in file_start
+                and b"__path__ = __import__('pkgutil').extend_path(__path__, __name__)"
+                not in file_start
+                and b'__path__ = __import__("pkgutil").extend_path(__path__, __name__)'
+                not in file_start
+            ):
+                return False
+    return True
+
+
+def _src_path_is_module(src_path: Path, module_name: str) -> bool:
+    return (
+        module_name == src_path.name and src_path.is_dir() and exists_case_sensitive(str(src_path))
+    )