Updated for tracking

slpkg/main.py

@@ -755,8 +755,8 @@ class Argparse(Configs):
 
             self.check.package_exists_in_the_database(packages)
 
-            tracking = Tracking(self.flags, self.repository)
-            tracking.packages(self.data, packages)
+            tracking = Tracking(self.data, packages, self.flags, self.repository)
+            tracking.package()
             raise SystemExit()
         self.usage.help_short(1)
 

slpkg/tracking.py

@@ -9,9 +9,12 @@ from slpkg.utilities import Utilities
 class Tracking(Configs):
     """ Tracking of the package dependencies. """
 
-    def __init__(self, flags: list, repository: str):
+    def __init__(self, data: dict, packages: list, flags: list, repository: str):
         super(Configs, self).__init__()
+        self.data: dict = data
+        self.packages: list = packages
         self.flags: list = flags
+        self.repository = repository
 
         self.ascii = Ascii()
         self.utils = Utilities()
@@ -25,53 +28,68 @@ class Tracking(Configs):
         self.option_for_pkg_version: bool = self.utils.is_option(
             ['-p', '--pkg-version'], flags)
 
-    def packages(self, data: dict, packages: list) -> None:
+    def package(self) -> None:
         """ Prints the packages dependencies. """
-        print(f"The list below shows the packages '{', '.join([p for p in packages])}' with dependencies:\n")
-
-        packages: list = self.utils.apply_package_pattern(data, packages)
-
-        char: str = f' {self.llc}{self.hl}'
-        sp: str = ' ' * 4
+        print(f"The list below shows the packages '{', '.join([p for p in self.packages])}' with dependencies:\n")
+        packages: tuple = tuple(self.utils.apply_package_pattern(self.data, self.packages))
 
         for package in packages:
-            how_many: int = 0
+            count: int = 0
             pkg: str = f'{self.yellow}{package}{self.endc}'
-
             if self.option_for_pkg_version:
-                if self.is_binary:
-                    version: str = data[package][0]
-                else:
-                    version: str = data[package][2]
-                pkg = f'{self.yellow}{package} {version}{self.endc}'
+                pkg = f'{self.yellow}{package} {self.choose_package_version(package)}{self.endc}'
 
-            if self.is_binary:
-                requires: list = data[package][6].split()
-            else:
-                requires: list = data[package][7].split()
+            requires: tuple = self.choose_requires(package)
 
             print(pkg)
-            print(char, end='')
+            print(f"{'':>1}{self.llc}{self.hl}", end='')
 
             if not requires:
-                print(f' {self.cyan}No dependencies{self.endc}')
+                print(f"{'':>1}{self.cyan}No dependencies{self.endc}")
             else:
-                for i, req in enumerate(requires, start=1):
-                    how_many += 1
+                for n, req in enumerate(requires, start=1):
+                    count += 1
                     require: str = f'{self.cyan}{req}{self.endc}'
 
                     if self.option_for_pkg_version:
+                        require: str = (f'{self.cyan}{req}{self.endc}'
+                                        f'{self.choose_dependency_version(req)}')
+
+                    self.print_require(n, require)
+            self.summary_of_tracking(count, package)
+
+    def summary_of_tracking(self, count: int, package: str):
+        print(f'\n{self.grey}{count} dependencies for {package}{self.endc}\n')
+
+    @staticmethod
+    def print_require(n: int, require: str) -> None:
+        if n == 1:
+            print(f"{'':>1}{require}")
+        else:
+            print(f"{'':>4}{require}")
+
+    def choose_dependency_version(self, require: str) -> str:
+        try:
             if self.is_binary:
-                            version: str = ' (not included)'
-                            if data.get(req):
-                                version: str = f' {self.yellow}{data[req][0]}{self.endc}'
+                version: str = f"{'':>1}(not included)"
+                if self.data.get(require):
+                    version: str = f"{'':>1}{self.yellow}{self.data[require][0]}{self.endc}"
             else:
-                            version: str = f' {self.yellow}{data[req][2]}{self.endc}'
-                        require: str = f'{self.cyan}{req}{self.endc}{version}'
+                version: str = f"{'':>1}{self.yellow}{self.data[require][2]}{self.endc}"
+        except KeyError:
+            version: str = ''
+        return version
 
-                    if i == 1:
-                        print(f' {require}')
+    def choose_package_version(self, package: str) -> str:
+        if self.is_binary:
+            version: str = self.data[package][0]
         else:
-                        print(f'{sp}{require}')
+            version: str = self.data[package][2]
+        return version
 
-            print(f'\n{self.grey}{how_many} dependencies for {package}{self.endc}\n')
+    def choose_requires(self, package: str) -> tuple:
+        if self.is_binary:
+            requires: tuple = self.data[package][6].split()
+        else:
+            requires: tuple = self.data[package][7].split()
+        return requires