feat: use DI

Author: seppzer0

.python-version

@@ -1 +1 @@
-3.13.3
+3.13.5

builder/__main__.py

@@ -6,10 +6,12 @@
 from pathlib import Path
 from importlib.metadata import version
 
+from builder.core import KernelBuilder, AssetsCollector
 from builder.tools import cleaning as cm, commands as ccmd, Logger as logger
 from builder.configs import ArgumentConfig, DirectoryConfig as dcfg
 from builder.engines import GenericContainerEngine
 from builder.commands import KernelCommand, AssetsCommand, BundleCommand
+from builder.managers import ResourceManager
 
 
 def __get_version() -> str:
@@ -264,35 +266,43 @@ def main(args: argparse.Namespace) -> None:
                 ccmd.launch(engined_cmd)
 
         case "local":
+            kernel_builder = KernelBuilder(
+                codename = args.codename,
+                base = args.base,
+                lkv = args.lkv,
+                clean_kernel = args.clean_kernel,
+                ksu = args.ksu,
+                defconfig = args.defconfig,
+                rmanager = ResourceManager(
+                    codename = args.codename,
+                    lkv = args.lkv,
+                    base = args.base
+                )
+            )
+            assets_collector = AssetsCollector(
+                codename = args.codename,
+                base = args.base,
+                chroot = args.chroot,
+                clean_assets = args.clean_assets,
+                rom_only = args.rom_only,
+                ksu = args.ksu,
+            )
+
             match args.command:
                 case "kernel":
-                    kc = KernelCommand(
-                        codename = args.codename,
-                        base = args.base,
-                        lkv = args.lkv,
-                        clean_kernel = args.clean_kernel,
-                        ksu = args.ksu,
-                        defconfig = args.defconfig,
-                    )
+                    kc = KernelCommand(kernel_builder=kernel_builder)
                     kc.execute()
+
                 case "assets":
-                    ac = AssetsCommand(
-                        codename = args.codename,
-                        base = args.base,
-                        chroot = args.chroot,
-                        clean_assets = args.clean_assets,
-                        rom_only = args.rom_only,
-                        ksu = args.ksu,
-                    )
+                    ac = AssetsCommand(assets_collector=assets_collector)
                     ac.execute()
-                case "bundle":
+
+                case "bundle":  
                     bc = BundleCommand(
-                        codename = args.codename,
-                        base = args.base,
-                        lkv = args.lkv,
+                        kernel_builder = kernel_builder,
+                        assets_collector = assets_collector,
                         package_type = args.package_type,
-                        ksu = args.ksu,
-                        defconfig = args.defconfig,
+                        base = args.base
                     )
                     bc.execute()
 

builder/commands/assets.py

@@ -1,27 +1,22 @@
+import logging
 from typing import Literal
 from pydantic import BaseModel
 
 from builder.core import AssetsCollector
+from builder.tools import banner, fileoperations as fo
 from builder.interfaces import ICommand
 
 
+log = logging.getLogger("ZeroKernelLogger")
+
+
 class AssetsCommand(BaseModel, ICommand):
     """Command responsible for launching the 'assets_collector' core module directly.
 
-    :param str codename: Device codename.
-    :param str base: Kernel source base.
-    :param Literal["full","minimal"] chroot: Chroot type.
-    :param bool rom_only: Flag indicating ROM-only asset collection.
-    :param bool ksu: Flag indicating KernelSU support.
+    :param builder.core.AssetsCollector assets_collector: Assets collector object.
     """
 
-    codename: str
-    base: str
-    chroot: Literal["full", "minimal"]
-    clean_assets: bool
-    rom_only: bool
-    ksu: bool
+    assets_collector: AssetsCollector
 
     def execute(self) -> None:
-        ac = AssetsCollector(**self.__dict__)
-        ac.run()
+        self.assets_collector.run()

builder/commands/bundle.py

@@ -10,57 +10,41 @@
 from builder.core import KernelBuilder, AssetsCollector
 from builder.tools import Logger, cleaning as cm, commands as ccmd, fileoperations as fo
 from builder.configs import DirectoryConfig as dcfg
-from builder.managers import ResourceManager
-from builder.interfaces import ICommand, IBundleCommand
+from builder.interfaces import ICommand
 
 
 log = logging.getLogger("ZeroKernelLogger")
 
 
-class BundleCommand(BaseModel, ICommand, IBundleCommand):
+class BundleCommand(BaseModel, ICommand):
     """Command that packages the artifacts produced both by 'kernel_builder' and 'assets_collector' core modules.
 
-    :param str base: Kernel source base.
-    :param str lkv: Linux kernel version.
+    :param builder.core.KernelBuilder kernel_builder: Kernel builder object.
+    :param builder.core.AssetsCollector assets_collector: Assets collector object.
     :param str package_type: Package type.
-    :param bool ksu: Flag indicating KernelSU support.
-    :param Optional[Path]=None defconfig: Path to custom defconfig.
+    :param str base: ROM base for the kernel.
     """
 
-    codename: str
-    base: str
-    lkv: str
+    kernel_builder: KernelBuilder
+    assets_collector: AssetsCollector
     package_type: str
-    ksu: bool
-    defconfig: Optional[Path] = None
+    base: str
 
-    def build_kernel(self, rom_name: str, clean_only: bool = False) -> None:
+    def build_kernel(self, rom_name: str, clean_only: Optional[bool] = False) -> None:
         if not dcfg.kernel.is_dir() or clean_only is True:
-            kb = KernelBuilder(
-                codename = self.codename,
-                base = rom_name,
-                lkv = self.lkv,
-                clean_kernel = clean_only,
-                ksu = self.ksu,
-                rmanager=ResourceManager(codename=self.codename, lkv=self.lkv, base=self.base),
-                defconfig = self.defconfig,
-            )
-            kb.run()
+            self.kernel_builder.clean_kernel = clean_only  # type: ignore
+
+            self.kernel_builder.run()
 
     @property
     def _rom_only_flag(self) -> bool:
         return True if "full" not in self.package_type else False
 
     def collect_assets(self, rom_name: str, chroot: Literal["full", "minimal"]) -> None:
-        ac = AssetsCollector(
-            codename = self.codename,
-            base = rom_name,
-            chroot = chroot,
-            clean_assets = True,
-            rom_only = self._rom_only_flag,
-            ksu = self.ksu,
-        )
-        ac.run()
+        self.assets_collector.clean_assets = True
+        self.assets_collector.rom_only = self._rom_only_flag
+
+        self.assets_collector.run()
 
     def conan_sources(self) -> None:
         print("\n", end="")
@@ -105,7 +89,7 @@ def conan_package(self, options: tuple[str, ...], reference: str) -> None:
             cmd += f" -o {option_name}={option_value}"
 
         # add codename as an option separately
-        cmd += f" -o codename={self.codename}"
+        cmd += f" -o codename={self.kernel_builder.codename}"
         ccmd.launch(cmd)
 
     @staticmethod
@@ -151,7 +135,7 @@ def execute(self) -> None:
                 # form Conan reference
                 name = "zero_kernel"
                 version = os.getenv("KVERSION")
-                user = self.codename
+                user = self.kernel_builder.codename
                 channel = ""
 
                 if ccmd.launch("git branch --show-current", get_output=True) == "main":

builder/commands/kernel.py

@@ -1,34 +1,21 @@
-from pathlib import Path
-from typing import Optional
+import logging
 from pydantic import BaseModel
 
 from builder.core import KernelBuilder
-from builder.managers import ResourceManager
+from builder.tools import banner, fileoperations as fo
 from builder.interfaces import ICommand
 
 
+log = logging.getLogger("ZeroKernelLogger")
+
+
 class KernelCommand(BaseModel, ICommand):
     """Command responsible for launching the 'kernel_builder' core module directly.
 
-    :param str codename: Device codename.
-    :param str base: Kernel source base.
-    :param str lkv: Linux kernel version.
-    :param bool clean_kernel: Flag to clean folder with kernel sources.
-    :param bool ksu: Flag indicating KernelSU support.
-    :param Optional[Path]=None defconfig: Path to custom defconfig.
+    :param builder.core.KernelBuilder kernel_builder: Kernel builder object.
     """
 
-    codename: str
-    base: str
-    lkv: str
-    clean_kernel: bool
-    ksu: bool
-    defconfig: Optional[Path] = None
+    kernel_builder: KernelBuilder
 
     def execute(self) -> None:
-        # create resource manager and pass it to the builder
-        kb = KernelBuilder(
-            **self.__dict__,
-            rmanager=ResourceManager(codename=self.codename, lkv=self.lkv, base=self.base)
-        )
-        kb.run()
+        self.kernel_builder.run()

builder/core/assets_collector.py

@@ -4,7 +4,7 @@
 from typing import Literal
 from pydantic import BaseModel
 
-from builder.tools import Logger, cleaning as cm, fileoperations as fo, banner
+from builder.tools import banner, fileoperations as fo, cleaning as cm
 from builder.clients import GithubApiClient, LineageOsApiClient, ParanoidAndroidApiClient
 from builder.configs import DirectoryConfig as dcfg
 from builder.interfaces import IAssetsCollector
@@ -106,7 +106,7 @@ def assets(self) -> list:
 
         return None
 
-    def _check(self) -> None:
+    def check(self) -> None:
         os.chdir(dcfg.root)
 
         # directory check
@@ -136,7 +136,7 @@ def run(self) -> None:
         banner.print_banner("zero asset collector")
 
         os.chdir(dcfg.root)
-        self._check()
+        self.check()
         os.chdir(dcfg.assets)
         # NOTE: call "self.assets" only once!
         assets = self.assets

builder/core/kernel_builder.py

@@ -215,7 +215,7 @@ def patch_strict_prototypes(self) -> None:
         }
 
         # the following files are not present in 4.14
-        if self._lkv_src != "4.14":
+        if self.lkv_src != "4.14":
             extra_non_414 = {
                 self.rmanager.paths[self.codename] /\
                 "drivers" /\
@@ -446,9 +446,9 @@ def patch_ksu(self) -> None:
         )
 
         # either patch kernel or KernelSU sources, depending on Linux kernel version
-        target_d = dcfg.root / "KernelSU" if self._lkv_src == "4.14" else self.rmanager.paths[self.codename]
+        target_d = dcfg.root / "KernelSU" if self.lkv_src == "4.14" else self.rmanager.paths[self.codename]
         fo.ucopy(
-            dcfg.root / "builder" / "modifications" / self._ucodename / self._lkv_src / patch_name,
+            dcfg.root / "builder" / "modifications" / self._ucodename / self.lkv_src / patch_name,
             target_d
         )
         os.chdir(target_d)
@@ -461,7 +461,7 @@ def patch_qcacld(self) -> None:
         goback = Path.cwd()
 
         fo.ucopy(
-            dcfg.root / "builder" / "modifications" / self._ucodename / self._lkv_src / patch_name,
+            dcfg.root / "builder" / "modifications" / self._ucodename / self.lkv_src / patch_name,
             self.rmanager.paths[self.codename]
         )
         os.chdir(self.rmanager.paths[self.codename])
@@ -494,7 +494,7 @@ def patch_kernel(self) -> None:
 
         # apply .patch files
         fo.ucopy(
-            dcfg.root / "builder" / "modifications" / self._ucodename / self._lkv_src,
+            dcfg.root / "builder" / "modifications" / self._ucodename / self.lkv_src,
             self.rmanager.paths[self.codename],
             ("kernelsu-compat.patch", "qcacld_pa.patch")
         )
@@ -521,7 +521,7 @@ def patch_kernel(self) -> None:
 
         # some patches only for ParanoidAndroid
         if self.base == "pa":
-            if self._lkv_src == "4.4":
+            if self.lkv_src == "4.4":
                 self.patch_qcacld()
             self.patch_ioctl()
 
@@ -580,7 +580,7 @@ def build(self) -> None:
                 .format(punits)
 
         # for PA's 4.14, extend the "make" command with additional variables
-        if (self.base, self._lkv_src) == ("pa", "4.14"):
+        if (self.base, self.lkv_src) == ("pa", "4.14"):
             cmd2 = f"{cmd2} LEX=flex YACC=bison"
 
         # launch and time the build process
@@ -600,7 +600,7 @@ def build(self) -> None:
         log.info("Done! Time spent for the build: %02d:%02d:%02d" % (hours, mins, secs))
 
     @property
-    def _lkv_src(self) -> str:
+    def lkv_src(self) -> str:
         """Linux kernel version in kernel source.
 
         :return: Linux kernel version found in sources.
@@ -640,7 +640,7 @@ def create_zip(self) -> None:
         )
 
         # define kernel versions: Linux and internal
-        verbase = self._lkv_src
+        verbase = self.lkv_src
         ver_int = os.getenv("KVERSION")
 
         # create the final ZIP file
@@ -677,7 +677,7 @@ def run(self) -> None:
         self.write_localversion()
         log.info("Done! Tools are configured!")
 
-        if self.lkv != self._lkv_src:
+        if self.lkv != self.lkv_src:
             log.error("Linux kernel version in sources is different what was specified in arguments")
             sys.exit(1)
 

builder/interfaces/__init__.py

@@ -1,5 +1,5 @@
 from .clients import IRomApiClient
 from .modules import IKernelBuilder, IAssetsCollector
 from .engines import IGenericContainerEngine
-from .commands import ICommand, IBundleCommand
+from .commands import ICommand
 from .managers import IResourceManager