winipedia-utils 0.4.43__py3-none-any.whl → 0.7.1__py3-none-any.whl

winipedia_utils/{modules → utils/modules}/module.py

@@ -17,15 +17,19 @@ from collections.abc import Callable, Sequence
 from importlib import import_module
 from pathlib import Path
 from types import ModuleType
-from typing import Any, cast
+from typing import Any
 
-from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.modules.class_ import (
+from winipedia_utils.utils.logging.logger import get_logger
+from winipedia_utils.utils.modules.class_ import (
     get_all_cls_from_module,
     get_all_methods_from_cls,
 )
-from winipedia_utils.modules.function import get_all_functions_from_module
-from winipedia_utils.modules.package import (
+from winipedia_utils.utils.modules.function import get_all_functions_from_module
+from winipedia_utils.utils.modules.inspection import (
+    get_qualname_of_obj,
+    get_unwrapped_obj,
+)
+from winipedia_utils.utils.modules.package import (
     get_modules_and_packages_from_package,
     make_dir_with_init_file,
     module_is_package,
@@ -329,24 +333,6 @@ def get_default_module_content() -> str:
     return '''"""module."""'''
 
 
-def inside_frozen_bundle() -> bool:
-    """Return True if the code is running inside a frozen bundle."""
-    return getattr(sys, "frozen", False)
-
-
-def get_def_line(obj: Any) -> int:
-    """Return the line number where a method-like object is defined."""
-    if isinstance(obj, property):
-        obj = obj.fget
-    unwrapped = inspect.unwrap(obj)
-    if hasattr(unwrapped, "__code__"):
-        return int(unwrapped.__code__.co_firstlineno)
-    # getsourcelines does not work if in a pyinstaller bundle or something
-    if inside_frozen_bundle():
-        return 0
-    return inspect.getsourcelines(unwrapped)[1]
-
-
 def get_module_of_obj(obj: Any, default: ModuleType | None = None) -> ModuleType:
     """Return the module name where a method-like object is defined.
 
@@ -368,14 +354,23 @@ def get_module_of_obj(obj: Any, default: ModuleType | None = None) -> ModuleType
     return module
 
 
-def get_qualname_of_obj(obj: Callable[..., Any] | type) -> str:
-    """Return the name of a method-like object."""
-    unwrapped = get_unwrapped_obj(obj)
-    return cast("str", unwrapped.__qualname__)
+def get_executing_module() -> ModuleType:
+    """Get the module where execution has started.
 
+    The executing module is the module that contains the __main__ attribute as __name__
+    E.g. if you run `python -m winipedia_utils.setup` from the command line,
+    then the executing module is winipedia_utils.modules.setup
 
-def get_unwrapped_obj(obj: Any) -> Any:
-    """Return the unwrapped version of a method-like object."""
-    if isinstance(obj, property):
-        obj = obj.fget  # get the getter function of the property
-    return inspect.unwrap(obj)
+    Returns:
+        The module where execution has started
+
+    Raises:
+        ValueError: If no __main__ module is found or if the executing module
+                    cannot be determined
+
+    """
+    main = sys.modules.get("__main__")
+    if main is None:
+        msg = "No __main__ module found"
+        raise ValueError(msg)
+    return main

winipedia_utils/{modules → utils/modules}/package.py

@@ -9,18 +9,24 @@ The utilities support both static package analysis and dynamic package manipulat
 making them suitable for code generation, testing frameworks, and package management.
 """
 
+import importlib.metadata
+import importlib.util
 import os
 import pkgutil
+import re
 import sys
 from collections.abc import Generator, Iterable
 from importlib import import_module
 from pathlib import Path
 from types import ModuleType
+from typing import Any
 
+import networkx as nx
 from setuptools import find_namespace_packages as _find_namespace_packages
 from setuptools import find_packages as _find_packages
 
-from winipedia_utils.logging.logger import get_logger
+import winipedia_utils
+from winipedia_utils.utils.logging.logger import get_logger
 
 logger = get_logger(__name__)
 
@@ -40,11 +46,11 @@ def get_src_package() -> ModuleType:
                        if only the test package exists
 
     """
-    from winipedia_utils.testing.convention import (  # noqa: PLC0415  # avoid circular import
+    from winipedia_utils.dev.testing.convention import (  # noqa: PLC0415  # avoid circular import
         TESTS_PACKAGE_NAME,
     )
 
-    packages = find_packages_as_modules(depth=0)
+    packages = find_packages_as_modules(depth=0, include_namespace_packages=True)
     return next(p for p in packages if p.__name__ != TESTS_PACKAGE_NAME)
 
 
@@ -178,7 +184,7 @@ def find_packages(
         find_packages(depth=1) might return ["package1", "package2"]
 
     """
-    from winipedia_utils.git.gitignore.config import (  # noqa: PLC0415
+    from winipedia_utils.dev.configs.gitignore import (  # noqa: PLC0415
         GitIgnoreConfigFile,  # avoid circular import
     )
 
@@ -283,10 +289,10 @@ def make_init_modules_for_package(path: str | Path | ModuleType) -> None:
         from get_default_init_module_content.
 
     """
-    from winipedia_utils.git.gitignore.gitignore import (  # noqa: PLC0415
+    from winipedia_utils.utils.git.gitignore.gitignore import (  # noqa: PLC0415
         walk_os_skipping_gitignore_patterns,  # avoid circular import
     )
-    from winipedia_utils.modules.module import (  # noqa: PLC0415
+    from winipedia_utils.utils.modules.module import (  # noqa: PLC0415
         to_path,  # avoid circular import
     )
 
@@ -313,7 +319,7 @@ def make_init_module(path: str | Path) -> None:
         Creates parent directories if they don't exist.
 
     """
-    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+    from winipedia_utils.utils.modules.module import (  # noqa: PLC0415  # avoid circular import
         get_default_init_module_content,
         to_path,
     )
@@ -349,7 +355,7 @@ def copy_package(
         with_file_content (bool, optional): copies the content of the files.
 
     """
-    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+    from winipedia_utils.utils.modules.module import (  # noqa: PLC0415  # avoid circular import
         create_module,
         get_isolated_obj_name,
         get_module_content_as_str,
@@ -379,7 +385,7 @@ def get_main_package() -> ModuleType:
 
     Even when this package is installed as a module.
     """
-    from winipedia_utils.modules.module import (  # noqa: PLC0415  # avoid circular import
+    from winipedia_utils.utils.modules.module import (  # noqa: PLC0415  # avoid circular import
         to_module_name,
     )
 
@@ -403,28 +409,88 @@ def get_main_package() -> ModuleType:
     raise ValueError(msg)
 
 
-def make_name_from_package(
-    package: ModuleType,
-    split_on: str = "_",
-    join_on: str = "-",
-    *,
-    capitalize: bool = True,
-) -> str:
-    """Make a name from a package.
-
-    takes a package and makes a name from it that is readable by humans.
-
-    Args:
-        package (ModuleType): The package to make a name from
-        split_on (str, optional): what to split the package name on. Defaults to "_".
-        join_on (str, optional): what to join the package name with. Defaults to "-".
-        capitalize (bool, optional): Whether to capitalize each part. Defaults to True.
-
-    Returns:
-        str: _description_
-    """
-    package_name = package.__name__.split(".")[-1]
-    parts = package_name.split(split_on)
-    if capitalize:
-        parts = [part.capitalize() for part in parts]
-    return join_on.join(parts)
+class DependencyGraph(nx.DiGraph):  # type: ignore [type-arg]
+    """A directed graph representing Python package dependencies."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize the dependency graph and build it immediately."""
+        super().__init__(*args, **kwargs)
+        self.build()
+
+    def build(self) -> None:
+        """Build the graph from installed Python distributions."""
+        for dist in importlib.metadata.distributions():
+            name = self.parse_distname_from_metadata(dist)
+            self.add_node(name)
+
+            requires = dist.requires or []
+            for req in requires:
+                dep = self.parse_pkg_name_from_req(req)
+                if dep:
+                    self.add_edge(name, dep)  # package → dependency
+
+    @staticmethod
+    def parse_distname_from_metadata(dist: importlib.metadata.Distribution) -> str:
+        """Extract the distribution name from its metadata."""
+        # replace - with _ to handle packages like winipedia-utils
+        name: str = dist.metadata["Name"]
+        return DependencyGraph.normalize_package_name(name)
+
+    @staticmethod
+    def normalize_package_name(name: str) -> str:
+        """Normalize a package name."""
+        return name.lower().replace("-", "_").strip()
+
+    @staticmethod
+    def parse_pkg_name_from_req(req: str) -> str | None:
+        """Extract the bare dependency name from a requirement string."""
+        # split on the first non alphanumeric character like >, <, =, etc.
+        # keep - and _ for names like winipedia-utils or winipedia_utils
+        dep = re.split(r"[^a-zA-Z0-9_-]", req.strip())[0].strip()
+        return DependencyGraph.normalize_package_name(dep) if dep else None
+
+    def get_all_depending_on(
+        self, package: ModuleType, *, include_self: bool = False
+    ) -> set[ModuleType]:
+        """Return all packages that directly or indirectly depend on the given package.
+
+        Args:
+            package: The module whose dependents should be found.
+            include_self: Whether to include the package itself in the result.
+
+        Returns:
+            A set of imported module objects representing dependents.
+        """
+        # replace - with _ to handle packages like winipedia-utils
+        target = package.__name__.lower()
+        if target not in self:
+            msg = f"Package '{target}' not found in dependency graph"
+            raise ValueError(msg)
+
+        dependents = nx.ancestors(self, target)
+        if include_self:
+            dependents.add(target)
+
+        return self.import_packages(dependents)
+
+    @staticmethod
+    def import_packages(names: set[str]) -> set[ModuleType]:
+        """Attempt to import all module names that can be resolved."""
+        modules: set[ModuleType] = set()
+        for name in names:
+            spec = importlib.util.find_spec(name)
+            if spec is not None:
+                modules.add(importlib.import_module(name))
+        return modules
+
+    def get_all_depending_on_winipedia_utils(
+        self, *, include_winipedia_utils: bool = False
+    ) -> set[ModuleType]:
+        """Return all packages that directly or indirectly depend on winipedia_utils."""
+        if get_src_package() == winipedia_utils:
+            deps: set[ModuleType] = set()
+        else:
+            deps = self.get_all_depending_on(winipedia_utils, include_self=False)
+        if include_winipedia_utils:
+            deps.add(winipedia_utils)
+        return deps

winipedia_utils/{oop → utils/oop}/mixins/meta.py

@@ -13,10 +13,10 @@ from collections.abc import Callable
 from functools import wraps
 from typing import Any, final
 
-from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.modules.class_ import get_all_methods_from_cls
-from winipedia_utils.modules.function import is_func, unwrap_method
-from winipedia_utils.text.string import value_to_truncated_string
+from winipedia_utils.utils.data.structures.text.string import value_to_truncated_string
+from winipedia_utils.utils.logging.logger import get_logger
+from winipedia_utils.utils.modules.class_ import get_all_methods_from_cls
+from winipedia_utils.utils.modules.function import is_func, unwrap_method
 
 logger = get_logger(__name__)
 

winipedia_utils/{oop → utils/oop}/mixins/mixin.py

@@ -10,8 +10,8 @@ These utilities help create robust class hierarchies with proper implementation
 enforcement and built-in logging capabilities.
 """
 
-from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.oop.mixins.meta import ABCLoggingMeta, StrictABCLoggingMeta
+from winipedia_utils.utils.logging.logger import get_logger
+from winipedia_utils.utils.oop.mixins.meta import ABCLoggingMeta, StrictABCLoggingMeta
 
 logger = get_logger(__name__)
 

winipedia_utils/{os → utils/os}/os.py

@@ -7,7 +7,7 @@ These utilities help with system-level operations and configuration.
 
 import shutil
 import subprocess  # nosec: B404
-from pathlib import Path
+from collections.abc import Sequence
 from typing import Any
 
 
@@ -34,7 +34,7 @@ def which_with_raise(cmd: str, *, raise_error: bool = True) -> str | None:
 
 
 def run_subprocess(
-    args: list[str | Path],
+    args: Sequence[str],
     *,
     input_: str | bytes | None = None,
     capture_output: bool = True,

winipedia_utils/utils/resources/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils/utils/resources/svgs/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils/{resources → utils/resources}/svgs/svg.py

@@ -4,7 +4,7 @@ from importlib.resources import as_file, files
 from pathlib import Path
 from types import ModuleType
 
-from winipedia_utils.resources import svgs
+from winipedia_utils.utils.resources import svgs
 
 
 def get_svg_path(svg_name: str, package: ModuleType | None = None) -> Path:

winipedia_utils/utils/testing/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils/{testing → utils/testing}/assertions.py

@@ -7,6 +7,8 @@ specialized validation logic for common testing scenarios.
 
 from typing import Any
 
+from winipedia_utils.utils.modules.function import is_abstractmethod
+
 
 def assert_with_msg(expr: bool, msg: str) -> None:  # noqa: FBT001
     """Assert that an expression is true with a custom error message.
@@ -46,3 +48,19 @@ Actual: {actual}
 {msg}
 """
     assert_with_msg(expr, msg)
+
+
+def assert_isabstrct_method(method: Any) -> None:
+    """Assert that a method is an abstract method.
+
+    Args:
+        method: The method to check
+
+    Raises:
+        AssertionError: If the method is not an abstract method
+
+    """
+    assert_with_msg(
+        is_abstractmethod(method),
+        f"Expected {method} to be abstract method",
+    )

winipedia_utils/{testing → utils/testing}/skip.py

@@ -4,7 +4,7 @@ import functools
 
 import pytest
 
-from winipedia_utils.git.github.github import running_in_github_actions
+from winipedia_utils.utils.git.github.github import running_in_github_actions
 
 skip_fixture_test: pytest.MarkDecorator = functools.partial(
     pytest.mark.skip,

{winipedia_utils-0.4.43.dist-info → winipedia_utils-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winipedia-utils
-Version: 0.4.43
+Version: 0.7.1
 Summary: A package with many utility functions
 License-Expression: MIT
 License-File: LICENSE
@@ -15,6 +15,7 @@ Requires-Dist: cryptography
 Requires-Dist: defusedxml
 Requires-Dist: dotenv
 Requires-Dist: keyring
+Requires-Dist: networkx
 Requires-Dist: pathspec
 Requires-Dist: polars
 Requires-Dist: pygithub
@@ -78,7 +79,8 @@ git clone https://github.com/owner/repo.git
 poetry init # or poetry new
 # 4: Poetry will ask you some stuff when you run poetry init.
 # First author name must be equal to the GitHub repository owner (username).
-# The repository name must be equal to the package/project name.
+# The repository name must be equal to the package/project name. 
+# (- instead of _ is fine, but only as the project name in pyproject.toml, folder names should all be _)
 
 # 5: Add winipedia-utils to your project
 poetry add winipedia-utils
@@ -103,7 +105,7 @@ The setup creates the following configuration files:
 - `.pre-commit-config.yaml` - Pre-commit hook configuration
 - `.gitignore` - Git ignore rules (assumes you added one on GitHub before.)
 - `pyproject.toml` - Project configuration with Poetry settings
-- `.github/workflows/health_check.yaml` - Health check workflow (Runs on every push and pull request, all workfows run on the latest possible python version in pyproject.toml)
+- `.github/workflows/health_check.yaml` - Health check workflow (Runs on every push and pull request using a matrix strategy to test across multiple operating systems and Python versions)
 - `.github/workflows/release.yaml` - Release workflow (Creates a release on GitHub when the same actions as in health check pass and commits are pushed to main)
 - `.github/workflows/publish.yaml` - Publishing workflow (Publishes to PyPI when a release is created by the release workflow, if you use this workflow, you need to add a PYPI_TOKEN (named PYPI_TOKEN) to your GitHub secrets that has write access to the package on PyPI.)
 - `py.typed` - PEP 561 marker for type hints
@@ -112,27 +114,60 @@ The setup creates the following configuration files:
 - `conftest.py` - Pytest configuration file
 - `.python-version` - Python version file for pyenv (if you use pyenv, puts in the lowest supported python version in pyproject.toml opposed to the latest possible python version in workflows)
 
+### GitHub Workflows and Matrix Strategy
+
+The project uses GitHub Actions workflows with a **matrix strategy** to ensure cross-platform compatibility:
+
+#### Matrix Configuration
+
+The health check and release workflows test your code across:
+- **Operating Systems**: Ubuntu (latest), Windows (latest), macOS (latest)
+- **Python Versions**: All versions specified in your `pyproject.toml` (e.g., 3.12, 3.13, 3.14)
+
+This matrix strategy ensures your code works reliably across different environments before merging or releasing.
+
+#### Workflow Structure
+
+The health check workflow consists of two jobs:
+
+1. **Matrix Job** (`health_check_matrix`) - Runs all checks in parallel across the matrix of OS and Python versions:
+   - Checkout repository
+   - Setup Git, Python, and Poetry
+   - Add Poetry to PATH (Windows-specific step)
+   - Install dependencies
+   - Setup CI keyring
+   - Protect repository (applies branch protection rules and repository settings)
+   - Run pre-commit hooks (linting, formatting, type checking, security, tests)
+
+2. **Aggregation Job** (`health_check`) - Aggregates matrix results into a single status check:
+   - Required for branch protection compatibility
+   - Only runs after all matrix jobs complete successfully
+   - Provides a single status check that can be marked as required in branch protection rules
+
+The release workflow extends the health check workflow and adds a release job that runs after all health checks pass.
+A build job is added before the release job if a script src/artifacts/build.py exists. This script is created by the setup command and can be modified to create build artifacts for your project. This script then just needs to create artifacts in a folder called artifacts and those will be uploaded as artifacts to the release.
+
 ### Pre-commit Hook Workflow
 
 When you commit code using `git commit`, the following checks run automatically:
 
 Info: If git commit fails bc of ModuleNotFoundError or smth similar, you need to run `poetry run git commit` instead.
 winipedia_utils hook is a python script that depends on winipedia_utils being installed. Poetry is needed to install winipedia_utils.
-Usually VSCode or other IDEs activates the venv automatically when opening the terminal but if not you need to activate it manually or run `poetry run git commit` instead.
-
-1. Patch version (poetry version patch)
-2. Add version patch to git (git add pyproject.toml)
-3. Update package manager (poetry self update)
-4. Install packages (poetry install --with dev)
-5. Update packages (poetry update --with dev (winipedia_utils forces all dependencies with * to be updated to latest compatible version))
-6. Lock dependencies (poetry lock)
-7. Check package manager configs (poetry check --strict)
-8. Create tests (python -m winipedia_utils.testing.create_tests)
-9. Lint code (ruff check --fix)
-10. Format code (ruff format)
-11. Check static types (mypy)
-12. Check security (bandit -c pyproject.toml -r .)
-13. Run tests (pytest (uses pyproject.toml as config))
+Usually VSCode or other IDEs activates the venv automatically when opening the terminal but if not you need to activate it manually or run `poetry run git commit` instead. It fails fast, so if one hook in winipedia_utils hook fails, the others don't run bc sys.exit(1) is called.
+
+Hooks run in the following order:
+
+- Update package manager (poetry self update)
+- Install packages (poetry install --with dev)
+- Update packages (poetry update --with dev (winipedia_utils forces all dependencies with * to be updated to latest compatible version))
+- Lock dependencies (poetry lock)
+- Check package manager configs (poetry check --strict)
+- Create tests (python -m winipedia_utils.dev.testing.create_tests)
+- Lint code (ruff check --fix)
+- Format code (ruff format)
+- Check static types (mypy)
+- Check security (bandit -c pyproject.toml -r .)
+- Run tests (pytest (uses pyproject.toml as config))
 
 ### Auto-generated Test Structure
 
@@ -168,7 +203,7 @@ Configuration files are managed automatically by the setup system:
 
 ## Branch Protection
 
-As soon as you push to `main` on GitHub (provided the `REPO_TOKEN` secret is set up correctly), the `health_check.yaml` workflow will run and execute `winipedia_utils.git.github.repo.protect`, which uses PyGithub to protect the repository.
+As soon as you push to `main` on GitHub (provided the `REPO_TOKEN` secret is set up correctly), the `health_check.yaml` workflow will run and execute `winipedia_utils.dev.git.github.repo.protect`, which uses PyGithub to protect the repository.
 
 ### Repository Settings
 
@@ -201,8 +236,8 @@ A ruleset named `main protection` is created for the `main` branch with the foll
   - Requires review thread resolution (all comments in reviews must be resolved before merge)
   - Allowed merge methods: `squash` and `rebase` (no merge commits, keeps history clean)
 - **Required Status Checks:**
-  - Strict mode enabled (all status checks must pass on the latest commit, not older ones (sets the health check as required status check))
-  - Health check workflow must pass (the CI/CD pipeline must complete successfully)
+  - Strict mode enabled (all status checks must pass on the latest commit, not older ones)
+  - Health check workflow must pass (the aggregated `health_check` job ensures all matrix combinations passed successfully)
 - **Bypass Actors** - Repository admins can bypass all rules (for emergency situations)
 
 ## Utilities
@@ -214,8 +249,8 @@ Winipedia Utils provides comprehensive utility modules for common development ta
 Unified interface for multiprocessing and multithreading:
 
 ```python
-from winipedia_utils.concurrent.multiprocessing import multiprocess_loop
-from winipedia_utils.concurrent.multithreading import multithread_loop
+from winipedia_utils.utils.iterating.concurrent.multiprocessing import multiprocess_loop
+from winipedia_utils.utils.iterating.concurrent.multithreading import multithread_loop
 ```
 
 ### Data Cleaning & Handling
@@ -223,7 +258,7 @@ from winipedia_utils.concurrent.multithreading import multithread_loop
 Build data cleaning pipelines using Polars:
 
 ```python
-from winipedia_utils.data.dataframe.cleaning import CleaningDF
+from winipedia_utils.utils.data.dataframe.cleaning import CleaningDF
 import polars as pl
 ```
 
@@ -232,7 +267,7 @@ import polars as pl
 Simple, standardized logging setup with automatic method instrumentation:
 
 ```python
-from winipedia_utils.logging.logger import get_logger
+from winipedia_utils.utils.logging.logger import get_logger
 
 logger = get_logger(__name__)
 logger.info("Application started")
@@ -250,7 +285,7 @@ logger.error("An error occurred")
 Advanced metaclasses and mixins for class composition and behavior extension:
 
 ```python
-from winipedia_utils.oop.mixins.mixin import ABCLoggingMixin, StrictABCLoggingMixin
+from winipedia_utils.utils.oop.mixins.mixin import ABCLoggingMixin, StrictABCLoggingMixin
 ```
 
 ### Security Utilities
@@ -258,7 +293,7 @@ from winipedia_utils.oop.mixins.mixin import ABCLoggingMixin, StrictABCLoggingMi
 Encryption and secure credential storage using keyring:
 
 ```python
-from winipedia_utils.security.keyring import (
+from winipedia_utils.utils.security.keyring import (
     get_or_create_fernet,
     get_or_create_aes_gcm
 )
@@ -269,8 +304,8 @@ from winipedia_utils.security.keyring import (
 Comprehensive testing framework with automatic test generation:
 
 ```python
-from winipedia_utils.testing.assertions import assert_with_msg
-from winipedia_utils.testing.convention import (
+from winipedia_utils.utils.testing.assertions import assert_with_msg
+from winipedia_utils.dev.testing.convention import (
     make_test_obj_name,
     get_test_obj_from_obj,
     make_test_obj_importpath_from_obj
@@ -300,10 +335,10 @@ test_path = make_test_obj_importpath_from_obj(my_function)
 Tools for working with Python modules, packages, classes, and functions:
 
 ```python
-from winipedia_utils.modules.package import find_packages, walk_package
-from winipedia_utils.modules.module import create_module, import_obj_from_importpath
-from winipedia_utils.modules.class_ import get_all_cls_from_module, get_all_methods_from_cls
-from winipedia_utils.modules.function import get_all_functions_from_module
+from winipedia_utils.utils.modules.package import find_packages, walk_package
+from winipedia_utils.utils.modules.module import create_module, import_obj_from_importpath
+from winipedia_utils.utils.modules.class_ import get_all_cls_from_module, get_all_methods_from_cls
+from winipedia_utils.utils.modules.function import get_all_functions_from_module
 ```
 
 ### Text and String Utilities
@@ -311,7 +346,7 @@ from winipedia_utils.modules.function import get_all_functions_from_module
 String manipulation and configuration file handling:
 
 ```python
-from winipedia_utils.text.string import value_to_truncated_string
+from winipedia_utils.utils.data.structures.text.string import value_to_truncated_string
 ```
 
 ### OS and System Utilities
@@ -319,7 +354,7 @@ from winipedia_utils.text.string import value_to_truncated_string
 Operating system and subprocess utilities:
 
 ```python
-from winipedia_utils.os.os import run_subprocess
+from winipedia_utils.utils.os.os import run_subprocess
 ```
 
 ### Iteration Utilities
@@ -327,7 +362,7 @@ from winipedia_utils.os.os import run_subprocess
 Utilities for working with iterables and nested structures:
 
 ```python
-from winipedia_utils.iterating.iterate import get_len_with_default, nested_structure_is_subset
+from winipedia_utils.utils.iterating.iterate import get_len_with_default, nested_structure_is_subset
 ```
 
 ### Philosophy