refactor: update depdendency versions

project_manager/__init__.py

@@ -1 +1 @@
-from .logging import *
+from .common.logging_custom import *

project_manager/command.py

@@ -25,23 +25,23 @@ class CommandLogger(threading.Thread):
         super().__init__()
         self.daemon = False
         self.level = level
-        self.fdRead, self.fdWrite = os.pipe()
-        self.pipeReader = os.fdopen(self.fdRead)
+        self._read_fd, self._write_fd = os.pipe()
+        self._reader_pipe = os.fdopen(self._read_fd)
         self.lines = []
         self.start()
 
     def fileno(self):
-        return self.fdWrite
+        return self._write_fd
 
     def run(self):
-        for line in iter(self.pipeReader.readline, ""):
+        for line in iter(self._reader_pipe.readline, ""):
             logger.log(self.level, line.strip("\n"))
             self.lines.append(line)
 
-        self.pipeReader.close()
+        self._reader_pipe.close()
 
     def close(self):
-        os.close(self.fdWrite)
+        os.close(self._write_fd)
 
 
 class CommandExecutor:

project_manager/common/logging_custom.py

@@ -1,12 +1,8 @@
+# pylint:disable=invalid-name
 import logging
 
 from termcolor import colored
 
-__all__ = (
-    "addLoggingLevel",
-    "CustomFormatter",
-)
-
 
 def addLoggingLevel(levelName, levelNum, methodName=None):
     """
@@ -37,17 +33,18 @@ def addLoggingLevel(levelName, levelNum, methodName=None):
         methodName = levelName.lower()
 
     if hasattr(logging, levelName):
-        raise AttributeError("{} already defined in logging module".format(levelName))
+        raise AttributeError(f"{levelName} already defined in logging module")
     if hasattr(logging, methodName):
-        raise AttributeError("{} already defined in logging module".format(methodName))
+        raise AttributeError(f"{methodName} already defined in logging module")
     if hasattr(logging.getLoggerClass(), methodName):
-        raise AttributeError("{} already defined in logger class".format(methodName))
+        raise AttributeError(f"{methodName} already defined in logger class")
 
     # This method was inspired by the answers to Stack Overflow post
     # http://stackoverflow.com/q/2183233/2988730, especially
     # http://stackoverflow.com/a/13638084/2988730
     def logForLevel(self, message, *args, **kwargs):
         if self.isEnabledFor(levelNum):
+            # pylint:disable=protected-access
             self._log(levelNum, message, args, **kwargs)
 
     def logToRoot(message, *args, **kwargs):

project_manager/main.py

@@ -1,49 +1,8 @@
-import logging
-import os
-import sys
-from argparse import ArgumentParser
-from pathlib import Path
-
-from project_manager.logging import CustomFormatter
-from project_manager.manager import ProjectManager
+from project_manager.runner import ProjectManagerRunner
 
 
 def run():
-    parser = ArgumentParser()
-    parser.add_argument(
-        "task",
-        nargs="?",
-        default="show",
-    )
-    parser.add_argument("-p", "--path", default=os.getcwd())
-    parser.add_argument("-v", "--verbose", action="count", default=1)
-    parser.add_argument("-q", "--quiet", action="store_true")
-    args = parser.parse_args()
-
-    logging_level = logging.WARNING
-    if args.verbose > 2:
-        logging_level = logging.TRACE
-    elif args.verbose > 1:
-        logging_level = logging.DEBUG
-    elif args.verbose > 0:
-        logging_level = logging.INFO
-    if args.quiet:
-        logging_level = logging.CRITICAL
-
-    stdout_handler = logging.StreamHandler()
-    stdout_handler.setFormatter(CustomFormatter("%(message)s"))
-
-    logging.basicConfig(
-        level=logging_level,
-        format="%(message)s",
-        handlers=[stdout_handler],
-    )
-
-    basepath = Path(args.path)
-    manager = ProjectManager(basepath)
-    result = manager.run_task(args.task)
-    if result["failed"] > 0:
-        sys.exit(1)
+    ProjectManagerRunner.from_args().run()
 
 
 if __name__ == "__main__":

project_manager/preset/default/python.toml

@@ -5,7 +5,7 @@ conditions = ["file(pyproject.toml)"]
 conditions = [
     "file(pyproject.toml) | get(build-system.build-backend) | equal(poetry.core.masonry.api)",
 ]
-variables.python_version = "file(pyproject.toml) | get(tool.poetry.dependencies.python) | search((\\d+.\\d+))"
+variables.python_version = "file(pyproject.toml) | get(project.requires-python) | search((\\d+.\\d+))"
 commands = [
     "poetry env use {python_version}",
     "poetry install",
@@ -29,6 +29,10 @@ commands = ["poetry publish -r {python_repository}"]
 conditions = ["file(.venv/bin/pytest)"]
 commands = [".venv/bin/python -m pytest"]
 
+[presets.python.tasks.lint.pylint]
+conditions = ["file(.venv/bin/pylint)"]
+commands = [".venv/bin/pylint ./"]
+
 [presets.python.tasks.lint.isort]
 conditions = ["file(.venv/bin/isort)"]
 commands = [".venv/bin/isort --profile black --check-only ./"]

project_manager/preset/model.py

@@ -1,5 +1,3 @@
-from typing import Dict, List, Optional
-
 from pydantic import BaseModel
 
 __all__ = (
@@ -10,16 +8,16 @@ __all__ = (
 
 
 class TaskPreset(BaseModel):
-    conditions: Optional[List[str]]
-    variables: Optional[Dict[str, str]]
-    commands: List[str]
+    conditions: list[str] | None = None
+    variables: dict[str, str] | None = None
+    commands: list[str]
 
 
 class EntryPreset(BaseModel):
-    conditions: Optional[List[str]]
-    tasks: Dict[str, Dict[str, TaskPreset]]
+    conditions: list[str] | None = None
+    tasks: dict[str, dict[str, TaskPreset]]
 
 
 class Preset(BaseModel):
-    skip: Optional[bool]
-    presets: Dict[str, EntryPreset]
+    skip: bool | None = None
+    presets: dict[str, EntryPreset]

project_manager/runner.py

@@ -0,0 +1,58 @@
+import logging
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import Self
+
+from .common.logging_custom import CustomFormatter
+from .manager import ProjectManager
+
+
+class ProjectManagerRunner:
+    def __init__(self, path: Path, task: str, verbose: int = 0):
+        self._path = path
+        self._task = task
+        self._verbose = verbose
+
+    @classmethod
+    def _setup_logging(cls, verbose: int):
+        logging_level = logging.WARNING
+        if verbose > 2:
+            logging_level = logging.TRACE
+        elif verbose > 1:
+            logging_level = logging.DEBUG
+        elif verbose > 0:
+            logging_level = logging.INFO
+        if verbose < 0:
+            logging_level = logging.CRITICAL
+
+        stdout_handler = logging.StreamHandler()
+        stdout_handler.setFormatter(CustomFormatter("%(message)s"))
+
+        logging.basicConfig(
+            level=logging_level,
+            format="%(message)s",
+            handlers=[stdout_handler],
+        )
+
+    def run(self):
+        self._setup_logging(self._verbose)
+        manager = ProjectManager(self._path)
+        result = manager.run_task(self._task)
+        if result["failed"] > 0:
+            sys.exit(1)
+
+    @classmethod
+    def from_args(cls) -> Self:
+        parser = ArgumentParser()
+        parser.add_argument(
+            "task",
+            nargs="?",
+            default="show",
+        )
+        parser.add_argument("-p", "--path", type=Path, default=Path.cwd())
+        parser.add_argument("-v", "--verbose", action="count", default=1)
+        parser.add_argument("-q", "--quiet", action="store_true")
+        args = parser.parse_args()
+        verbose = -1 if args.quiet else args.verbose
+        return cls(args.path, args.task, verbose)