drawlib 0.1.6__tar.gz → 0.1.7__tar.gz

{drawlib-0.1.6 → drawlib-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drawlib
-Version: 0.1.6
+Version: 0.1.7
 Summary: Python drawing library. Illustration as Code.
 Home-page: https://www.drawlib.com
 Author: Yuichi Ito

{drawlib-0.1.6 → drawlib-0.1.7}/drawlib/__init__.py

@@ -24,7 +24,7 @@ subpackages contains latest and old implementations.
 from typing import Final
 
 # please update here when you release new version
-VERSION = "0.1.6"
+VERSION = "0.1.7"
 
 # might not be changed
 LIB_NAME: Final[str] = "drawlib"

{drawlib-0.1.6 → drawlib-0.1.7}/drawlib/v0_1/apis.py

@@ -117,9 +117,6 @@ from drawlib.v0_1.private.icons import (
 ### Utilities ###
 #################
 
-from drawlib.v0_1.private.tools import (
-    dexec,
-)
 from drawlib.v0_1.private import (
     dutil,
 )

drawlib-0.1.7/drawlib/v0_1/private/command.py

@@ -0,0 +1,385 @@
+# Copyright (c) 2024 Yuichi Ito (yuichi@yuichi.com)
+#
+# This software is licensed under the Apache License, Version 2.0.
+# For more information, please visit: https://github.com/yuichi110/drawlib
+#
+# This software is provided "as is", without warranty of any kind,
+# express or implied, including but not limited to the warranties of
+# merchantability, fitness for a particular purpose and noninfringement.
+
+"""Handle drawlib command
+
+Entry point ``__main__`` calls this module's function ``call()``.
+After that class ``DrawlibArgParser`` parse options.
+Then operate appropriate actions.
+
+"""
+
+import os
+import sys
+import argparse
+from typing import Optional, List, Final
+import importlib.util
+import traceback
+
+import drawlib
+import drawlib.v0_1
+from drawlib.v0_1.private.logging import logger
+from drawlib.v0_1.private.settings import dsettings
+from drawlib.v0_1.private.util import (
+    error_handler,
+    get_script_relative_path,
+)
+from drawlib.v0_1.private.core_canvas.canvas import clear
+
+
+def call() -> None:
+    """drawlib command handling function.
+
+    This method is called from each API's ``__main__`` module.
+    If the API is latest, called from root package's ``__main__`` module too.
+
+    Abstract procedure of this function.
+
+    1. Crate DrawlibArgParser instance.
+    2. Parse command line options
+    3. If options requests version info, show it and quit.
+    4. Apply options such as logging level
+    5. get target files and directories which drawlib run.
+    6. call ``tools.run()`` for each files, directories
+
+    Returns:
+        None
+
+    """
+
+    argparser = DrawlibArgParser()
+    argparser.parse()
+    argparser.show_version_then_exit0_if_requested()
+    argparser.apply_options()
+    paths = argparser.get_positional_args()
+
+    if len(paths) == 0:
+        logger.critical("no input files and directories")
+        logger.critical('check options with "drawlib --help"')
+        sys.exit(1)
+
+    for path in paths:
+        if not os.path.isfile(path) and not os.path.isdir(path):
+            msg = f'ignore arg "{path}" since it is not a file/dir path'
+            logger.warning(msg)
+            continue
+
+        abspath = os.path.abspath(path)
+        realpath = os.path.realpath(abspath)
+        executer = DrawlibExecuter()
+        executer.execute(realpath)
+
+
+class DrawlibArgParser:
+    """drawlib ArgParser Class"""
+
+    def __init__(self) -> None:
+        """Initializa DrawlibArgParser
+
+        In this method, create ``ArgumentParser`` instance and
+        define command line options.
+
+        Returns:
+            None
+
+        """
+
+        parser = argparse.ArgumentParser(
+            description="Ilustration as code by python",
+        )
+        parser.add_argument(
+            "file_or_directory",
+            nargs="...",
+            help="Target python file or directory which contains python codes",
+        )
+        parser.add_argument(
+            "-v",
+            "--version",
+            action="store_true",
+            help="Show version",
+        )
+        parser.add_argument(
+            "--quiet",
+            action="store_true",
+            help="Enable quiet logging. show only error messages",
+        )
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Enable verbose logging.",
+        )
+        parser.add_argument(
+            "--developer",
+            action="store_true",
+            help=("Enable verbose logging. " "Disable error handling for library users."),
+        )
+        self._parser = parser
+        self._positional_args: Optional[List[str]] = None
+        self._name_args: Optional[argparse.Namespace] = None
+
+    def parse(self) -> None:
+        """Parse command line options.
+
+        Parse command line options.
+        This method must be called before calling get methods.
+
+        Returns:
+            None
+
+        """
+
+        self._name_args, _ = self._parser.parse_known_args()
+        args = self._parser.parse_args()
+        self._positional_args = args.file_or_directory
+
+    def get_positional_args(self) -> List[str]:
+        """Get positional args. which are files and directories.
+
+        drawlib command requires files and directories as positional args.
+        They are the target of ``tool.run()`` function.
+        It means specified file or files inside directories
+        are called from python.
+        If those python files are drawlib's one, generate images.
+
+        This method must be called after ``parse()`` method is called.
+
+        Returns:
+            List[str]: Positional args (files and directories)
+
+        """
+
+        if self._positional_args is None:
+            logger.critical("DrawlibArgParser must be parsed before getting optional args")
+            sys.exit(1)
+
+        return self._positional_args
+
+    def show_version_then_exit0_if_requested(self) -> None:
+        """show version if option ``-v/`` or ``--version`` exists. And then quit.
+
+        Check whether option has ``-v`` or ``--version``.
+        If yes, show version. And then, quit with ``sys.exit(0)``.
+
+        Returns:
+            None
+
+        """
+
+        if self._name_args is None:
+            logger.critical("DrawlibArgParser must be parsed before apply options")
+            sys.exit(1)
+
+        if self._name_args.version:
+            logger.critical(f"software={drawlib.VERSION}")
+            logger.critical(f"api={drawlib.v0_1.VERSION}")
+            sys.exit(0)
+
+    def apply_options(self) -> None:
+        """Check named args and apply appropriate configs.
+
+        Check these named argses. And do appropriate actions.
+
+        * --quiet: make logging mode quiet
+        * --debug: make logging mode verbose
+        * --devdebug: make logging mode developer
+
+        Returns:
+            None
+
+        """
+
+        if self._name_args is None:
+            logger.critical("DrawlibArgParser must be parsed before apply options")
+            sys.exit(1)
+
+        if self._name_args.quiet and (self._name_args.verbose or self._name_args.developer):
+            raise ValueError("option --quiet can't use with option --debug and --devdebug")
+
+        if self._name_args.quiet:
+            dsettings.set_logging_mode("quiet")
+
+        if self._name_args.verbose:
+            dsettings.set_logging_mode("verbose")
+
+        if self._name_args.developer:
+            dsettings.set_logging_mode("developer")
+
+
+class DrawlibExecuter:
+
+    def __init__(self) -> None:
+        self._topdir_path: str = ""
+
+    @error_handler
+    def execute(self, file_or_directory: str, auto_clear: bool = True) -> None:
+        """Run specified python file or python files in specified directory
+
+        Call python file via OS path.
+        When you specify python file, only run it.
+        When you specify directory, run all python files recursively inside it.
+        Each python files are called only 1 time.
+        2nd time call is skipped.
+
+        When file1.py calls ``run("file2.py")`` and file2.py calls
+        ``run("file3.py")``, loading file3.py first.
+        This recursive load situation can be checked on console.
+        Please don't make circular loading situation.
+
+        Note:
+            We recommend creating ``.drawlib`` directory and put all python files which are loaded.
+            Each drawing python file need to declare only ``run(<path_to_.drawlib>)``.
+
+        Strongly recommend ``auto_clear=True`` when specifying directory.
+        If user code doesn't call ``clear()``,
+        canvas state is shared between python files.
+        It means 2nd draw can contain 1st draw results.
+        Default value of ``auto_clear`` is True.
+
+        Args:
+            file_or_directory: run target. relative to user script path.
+            auto_clear(optional): call ``clear()`` method between running each python files.
+
+        Returns:
+            None
+
+        """
+
+        path = get_script_relative_path(file_or_directory)
+        if not os.path.exists(path):
+            raise ValueError(f'"{path}" does not exist')
+
+        self._add_topdir_to_syspath(path)
+
+        logger.info("Execute python files")
+        if os.path.isfile(path):
+            if not path.endswith(".py"):
+                raise ValueError(f'Unable to run "{path}"')
+            self._exec_module(path, auto_clear)
+        else:
+            file_paths = self._get_python_files(path)
+            for file_path in file_paths:
+                self._exec_module(file_path, auto_clear)
+
+    def _add_topdir_to_syspath(self, path: str):
+        if os.path.isfile(path):
+            topdir = os.path.dirname(path)
+        else:
+            init_path = os.path.join(path, "__init__.py")
+            if not os.path.exists(init_path):
+                logger.critical(f'Target directory "{path}" does not have __init__.py. Abort.')
+                sys.exit(1)
+            topdir = path
+
+        package_dir = ""
+        while os.path.exists(os.path.join(topdir, "__init__.py")):
+            package_dir = topdir
+            topdir = os.path.dirname(topdir)
+
+        self._topdir_path = topdir
+        logger.info(f'Detect package root "{package_dir}".')
+        if topdir not in sys.path:
+            sys.path.append(topdir)
+            logger.info(f'    - Add parent directory of package root "{topdir}" to Python Path.')
+        else:
+            logger.info(f'    - Parent of package directory "{topdir}" is already in Python Path.')
+        logger.info("")
+
+    def _get_python_files(self, directory: str) -> List[str]:
+        python_files: List[str] = []
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if file.endswith(".py"):
+                    file_path = os.path.join(root, file)
+                    python_files.append(file_path)
+
+        sorted_files = sorted(python_files, key=lambda path: path.count(os.sep))
+        return sorted_files
+
+    def _exec_module(self, file_path: str, auto_clear: bool) -> None:
+        """write docstring later"""
+
+        words = self._get_package_words(file_path)
+        self._load_parent_modules(words)
+
+        if self._is_module_loaded(file_path):
+            logger.info(f"    - {file_path}")
+            return
+
+        # load module
+        name = ".".join(words).replace(".py", "")
+        mspec = importlib.util.spec_from_file_location(
+            name=name,
+            location=file_path,
+        )
+        if mspec is None:
+            # need to investigate what situation make this
+            logger.info(f"    - {file_path} : skipped with unknown reason.")
+            return
+        module = importlib.util.module_from_spec(mspec)
+
+        # execute and cache
+        try:
+            if auto_clear:
+                clear()
+            logger.info(f"    - {file_path}")
+            mspec.loader.exec_module(module)  # type: ignore[union-attr]
+            sys.modules[name] = module
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            # Please don't raise again.
+            # Error handler can't detect exact error location of imported module
+            file, line, _, _ = traceback.extract_tb(e.__traceback__)[-1]
+            logger.critical(f'{type(e).__name__} at file:"{file}", line:"{line}"')
+            logger.critical(str(e))
+            logger.debug("")
+            logger.debug(traceback.format_exc())
+            sys.exit(1)
+
+    def _is_module_loaded(self, module_path: str) -> bool:
+        # Normalize the module path to ensure consistent comparison
+        module_path = os.path.abspath(module_path)
+
+        for module_name, module in sys.modules.items():
+            if module is None:
+                continue
+            if not hasattr(module, "__file__"):
+                continue
+            if module.__file__ is None:
+                continue
+
+            loaded_module_path = os.path.abspath(module.__file__)
+            if loaded_module_path == module_path:
+                return True
+
+        return False
+
+    def _get_package_words(self, file_path):
+        last_path = file_path.replace(self._topdir_path, "")
+        words = last_path.split(os.sep)
+        if words[0] == "":
+            words = words[1:]
+        return words
+
+    def _load_parent_modules(self, words: List[str]):
+        for i in range(1, len(words)):
+            name = ".".join(words[:i])
+            if name in sys.modules:
+                continue
+
+            location = os.path.join(self._topdir_path, os.sep.join(words[:i]), "__init__.py")
+            if not os.path.exists(location):
+                raise ValueError(f'"{location}" does not exist. Please create it first.')
+
+            mspec = importlib.util.spec_from_file_location(
+                name=name,
+                location=location,
+            )
+            module = importlib.util.module_from_spec(mspec)
+            mspec.loader.exec_module(module)
+            sys.modules[name] = module

{drawlib-0.1.6 → drawlib-0.1.7}/drawlib/v0_1/private/core/theme.py

@@ -93,6 +93,7 @@ class Theme:
 
     @dataclasses.dataclass
     class ThemeStyle:
+        # mandatory for default
         backgroundcolor: Union[Tuple[int, int, int], Tuple[int, int, int, float], None] = None
         sourcecodefont: Optional[FontSourceCode] = None
         iconstyle: Optional[IconStyle] = None
@@ -103,8 +104,14 @@ class Theme:
         shapetextstyle: Optional[ShapeTextStyle] = None
         textstyle: Optional[TextStyle] = None
 
+        # optional for default
+        arcstyle: Optional[ShapeStyle] = None
+        arttextstyle: Optional[ShapeTextStyle] = None
+
     @error_handler
     def __init__(self):
+        self._style_names: List[str] = []
+
         self.backgroundcolors = BackgroundColors()
         self.sourcecodefonts = SourceCodeFonts()
         self.iconstyles = IconStyles()
@@ -174,6 +181,8 @@ class Theme:
 
         """
 
+        self._style_names: List[str] = []
+
         self.backgroundcolors = BackgroundColors()
         self.sourcecodefonts = SourceCodeFonts()
         self.iconstyles = IconStyles()
@@ -291,6 +300,8 @@ class Theme:
         # initialize
         self._initialize()
 
+        self._style_names.append("")
+
         # set default background color
         _check_color(
             default_style.backgroundcolor,
@@ -335,6 +346,8 @@ class Theme:
 
         # named styles
         for name, styles in named_styles:
+            self._style_names.append(name)
+
             if styles.backgroundcolor is not None:
                 _check_color(
                     styles.backgroundcolor,
@@ -383,6 +396,76 @@ class Theme:
                     raise ValueError(f"name={name}, ThemeStyle.textstyle type must be TextStyle.")
                 self.textstyles.set(styles.textstyle, name)
 
+    @error_handler
+    def print_style_table(self) -> None:
+        print(self._get_style_table())
+
+    def _get_style_table(self) -> str:
+        lines: List[str] = []
+
+        col1: List[str] = [
+            "",
+            "IconStyle",
+            "ImageStyle",
+            "LineStyle",
+            "LineArrowStyle",
+            "ShapeStyle",
+            "ShapeTextStyle",
+            "TextStyle",
+        ]
+
+        row_objects = [
+            self.iconstyles,
+            self.imagestyles,
+            self.linestyles,
+            self.linearrowstyles,
+            self.shapestyles,
+            self.shapetextstyles,
+            self.textstyles,
+        ]
+
+        # create columns
+        cols: List[List[str]] = [col1]
+        for style_name in self._style_names:
+            col: List[str] = [style_name]
+            for row_object in row_objects:
+                if row_object.has(style_name):
+                    col.append("x")
+                else:
+                    col.append("")
+            cols.append(col)
+
+        # modify text length
+        cols2 = []
+        for col in cols:
+            max_length = max(len(s) for s in col)
+            padded_strings = [s.ljust(max_length) for s in col]
+            cols2.append(padded_strings)
+
+        def draw_border():
+            text = "+"
+            for col in cols2:
+                t = "-" * (len(col[0]) + 2)
+                text += f"{t}+"
+            lines.append(text)
+
+        for i in range(len(col1)):
+            if i == 0:
+                draw_border()
+
+            text = "|"
+            for col in cols2:
+                text += f" {col[i]} |"
+            lines.append(text)
+
+            if i == 0:
+                draw_border()
+
+            if i == len(col1) - 1:
+                draw_border()
+
+        return "\n".join(lines).strip()
+
 
 def _check_color(color, error_message: str):
 

{drawlib-0.1.6 → drawlib-0.1.7}/drawlib/v0_1/private/core/theme_officials.py

@@ -407,30 +407,41 @@ def _add_special_name_styles(
     ]
 ]:
     new_named_styles = deepcopy(named_styles)
-    default_shapetextstyle = default_styles[5]
 
     # add white ShapeTextStyle
-    if not isinstance(default_shapetextstyle, ShapeTextStyle):
-        raise ValueError()
-    white_shapetextstyle = default_shapetextstyle.copy()
-    white_shapetextstyle.color = Colors.White
-    new_named_styles.append(("white", [white_shapetextstyle]))
+    has_named_style_white = False
+    for named_style in new_named_styles:
+        name = named_style[0]
+        if name == "white":
+            has_named_style_white = True
+
+    if not has_named_style_white:
+        default_shapetextstyle = default_styles[5]
+        if not isinstance(default_shapetextstyle, ShapeTextStyle):
+            raise ValueError()
+        white_shapetextstyle = default_shapetextstyle.copy()
+        white_shapetextstyle.color = Colors.White
+        new_named_styles.append(("white", [white_shapetextstyle]))
 
     # add IconStyle and LineArrowStyle with new names
-    for name, styles in named_styles:
+    inserted = 0
+    for i, (name, styles) in enumerate(named_styles, start=1):
         icon, image, line, linearrow, shape, shapetext, text = styles
         if isinstance(icon, IconStyle) and isinstance(shape, ShapeStyle):
             icon_lcolor = icon.copy()
             icon_lcolor.color = shape.lcolor
             icon_fcolor = icon.copy()
             icon_fcolor.color = shape.fcolor
-            new_named_styles.append((f"lcolor-{name}", [icon_lcolor]))
-            new_named_styles.append((f"fcolor-{name}", [icon_fcolor]))
+            new_named_styles.insert(i + inserted, (f"lc-{name}", [icon_lcolor]))
+            inserted += 1
+            new_named_styles.insert(i + inserted, (f"fc-{name}", [icon_fcolor]))
+            inserted += 1
         else:
             raise ValueError()
 
         if isinstance(linearrow, LineArrowStyle):
-            new_named_styles.append((f"linearrow-{name}", [linearrow]))
+            new_named_styles.insert(i + inserted, (f"la-{name}", [linearrow]))
+            inserted += 1
         else:
             raise ValueError()
 

{drawlib-0.1.6 → drawlib-0.1.7}/drawlib/v0_1/private/settings.py

@@ -118,7 +118,7 @@ class DrawlibSettings:
         else:
             logger.critical(f'logging mode "{mode}" is not supported.')
             sys.exit(1)
-        logger.debug(f'set_log_mode(): "{mode}"')
+        # logger.debug(f'set_log_mode(): "{mode}"')
 
         self._logging_mode = mode
 

{drawlib-0.1.6 → drawlib-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "drawlib"
-version = "0.1.6"
+version = "0.1.7"
 description = "Python drawing library. Illustration as Code."
 homepage = "https://www.drawlib.com"
 repository = "https://github.com/yuichi110/drawlib"
@@ -29,6 +29,4 @@ radon = "^6.0.1"
 bandit = "^1.7.8"
 pytest-cov = "^5.0.0"
 pydocstyle = "^6.3.0"
-sphinx = "^7.2.6"
-sphinx-rtd-theme = "^2.0.0"
 toml = "^0.10.2"

drawlib-0.1.6/drawlib/v0_1/private/command.py

@@ -1,204 +0,0 @@
-# Copyright (c) 2024 Yuichi Ito (yuichi@yuichi.com)
-#
-# This software is licensed under the Apache License, Version 2.0.
-# For more information, please visit: https://github.com/yuichi110/drawlib
-#
-# This software is provided "as is", without warranty of any kind,
-# express or implied, including but not limited to the warranties of
-# merchantability, fitness for a particular purpose and noninfringement.
-
-"""Handle drawlib command
-
-Entry point ``__main__`` calls this module's function ``call()``.
-After that class ``DrawlibArgParser`` parse options.
-Then operate appropriate actions.
-
-"""
-
-import os
-import sys
-import argparse
-from typing import Optional, List
-import drawlib
-import drawlib.v0_1
-from drawlib.v0_1.private.logging import logger
-from drawlib.v0_1.private.settings import dsettings
-from drawlib.v0_1.private.tools import dexec
-
-
-def call() -> None:
-    """drawlib command handling function.
-
-    This method is called from each API's ``__main__`` module.
-    If the API is latest, called from root package's ``__main__`` module too.
-
-    Abstract procedure of this function.
-
-    1. Crate DrawlibArgParser instance.
-    2. Parse command line options
-    3. If options requests version info, show it and quit.
-    4. Apply options such as logging level
-    5. get target files and directories which drawlib run.
-    6. call ``tools.run()`` for each files, directories
-
-    Returns:
-        None
-
-    """
-
-    argparser = DrawlibArgParser()
-    argparser.parse()
-    argparser.show_version_then_exit0_if_requested()
-    argparser.apply_options()
-    paths = argparser.get_positional_args()
-
-    if len(paths) == 0:
-        logger.critical("no input files and directories")
-        logger.critical('check options with "drawlib --help"')
-        sys.exit(1)
-
-    for path in paths:
-        if not os.path.isfile(path) and not os.path.isdir(path):
-            msg = f'ignore arg "{path}" since it is not a file/dir path'
-            logger.warning(msg)
-            continue
-
-        abspath = os.path.abspath(path)
-        realpath = os.path.realpath(abspath)
-        logger.info(realpath)
-        dexec(realpath)
-
-
-class DrawlibArgParser:
-    """drawlib ArgParser Class"""
-
-    def __init__(self) -> None:
-        """Initializa DrawlibArgParser
-
-        In this method, create ``ArgumentParser`` instance and
-        define command line options.
-
-        Returns:
-            None
-
-        """
-
-        parser = argparse.ArgumentParser(
-            description="Ilustration as code by python",
-        )
-        parser.add_argument(
-            "file_or_directory",
-            nargs="...",
-            help="Target python file or directory which contains python codes",
-        )
-        parser.add_argument(
-            "-v",
-            "--version",
-            action="store_true",
-            help="Show version",
-        )
-        parser.add_argument(
-            "--quiet",
-            action="store_true",
-            help="Enable quiet logging. show only error messages",
-        )
-        parser.add_argument(
-            "--verbose",
-            action="store_true",
-            help="Enable verbose logging.",
-        )
-        parser.add_argument(
-            "--developer",
-            action="store_true",
-            help=("Enable verbose logging. " "Disable error handling for library users."),
-        )
-        self._parser = parser
-        self._positional_args: Optional[List[str]] = None
-        self._name_args: Optional[argparse.Namespace] = None
-
-    def parse(self) -> None:
-        """Parse command line options.
-
-        Parse command line options.
-        This method must be called before calling get methods.
-
-        Returns:
-            None
-
-        """
-
-        self._name_args, _ = self._parser.parse_known_args()
-        args = self._parser.parse_args()
-        self._positional_args = args.file_or_directory
-
-    def get_positional_args(self) -> List[str]:
-        """Get positional args. which are files and directories.
-
-        drawlib command requires files and directories as positional args.
-        They are the target of ``tool.run()`` function.
-        It means specified file or files inside directories
-        are called from python.
-        If those python files are drawlib's one, generate images.
-
-        This method must be called after ``parse()`` method is called.
-
-        Returns:
-            List[str]: Positional args (files and directories)
-
-        """
-
-        if self._positional_args is None:
-            logger.critical("DrawlibArgParser must be parsed before getting optional args")
-            sys.exit(1)
-
-        return self._positional_args
-
-    def show_version_then_exit0_if_requested(self) -> None:
-        """show version if option ``-v/`` or ``--version`` exists. And then quit.
-
-        Check whether option has ``-v`` or ``--version``.
-        If yes, show version. And then, quit with ``sys.exit(0)``.
-
-        Returns:
-            None
-
-        """
-
-        if self._name_args is None:
-            logger.critical("DrawlibArgParser must be parsed before apply options")
-            sys.exit(1)
-
-        if self._name_args.version:
-            logger.critical(f"software={drawlib.VERSION}")
-            logger.critical(f"api={drawlib.v0_1.VERSION}")
-            sys.exit(0)
-
-    def apply_options(self) -> None:
-        """Check named args and apply appropriate configs.
-
-        Check these named argses. And do appropriate actions.
-
-        * --quiet: make logging mode quiet
-        * --debug: make logging mode verbose
-        * --devdebug: make logging mode developer
-
-        Returns:
-            None
-
-        """
-
-        if self._name_args is None:
-            logger.critical("DrawlibArgParser must be parsed before apply options")
-            sys.exit(1)
-
-        if self._name_args.quiet and (self._name_args.verbose or self._name_args.developer):
-            raise ValueError("option --quiet can't use with option --debug and --devdebug")
-
-        if self._name_args.quiet:
-            dsettings.set_logging_mode("quiet")
-
-        if self._name_args.verbose:
-            dsettings.set_logging_mode("verbose")
-
-        if self._name_args.developer:
-            dsettings.set_logging_mode("developer")

drawlib-0.1.6/drawlib/v0_1/private/tools.py

@@ -1,161 +0,0 @@
-# Copyright (c) 2024 Yuichi Ito (yuichi@yuichi.com)
-#
-# This software is licensed under the Apache License, Version 2.0.
-# For more information, please visit: https://github.com/yuichi110/drawlib
-#
-# This software is provided "as is", without warranty of any kind,
-# express or implied, including but not limited to the warranties of
-# merchantability, fitness for a particular purpose and noninfringement.
-
-"""This module defines tool functions
-
-Note:
-    This module's concept is very similar to util module.
-    However, please don't merge them.
-    
-    This module is created for avoiding circular import between ``canvas`` and ``util``.
-    Function ``run()`` depends on ``canvas`` and ``canvas_singleton``.
-    And ``canvas`` and core modules depends on ``util``.
-    If you move function ``run()`` to ``util``, it makes import trouble.
-
-"""
-
-# pylint: disable=logging-fstring-interpolation
-# pylint: disable=global-statement
-
-import os
-from typing import Set, List, Final
-import importlib.util
-import traceback
-import sys
-
-from drawlib.v0_1.private.logging import logger
-from drawlib.v0_1.private.util import (
-    error_handler,
-    get_script_relative_path,
-)
-from drawlib.v0_1.private.core_canvas.canvas import clear
-
-
-class DrawlibExecuter:
-    _INDENT_SIZE: Final[int] = 4
-
-    def __init__(self) -> None:
-        self._executed_files: Set[str] = set()
-        self._load_stack: int = 0
-
-    @error_handler
-    def dexec(self, file_or_directory: str, auto_clear: bool = True) -> None:
-        """Run specified python file or python files in specified directory
-
-        Call python file via OS path.
-        When you specify python file, only run it.
-        When you specify directory, run all python files recursively inside it.
-        Each python files are called only 1 time.
-        2nd time call is skipped.
-
-        When file1.py calls ``run("file2.py")`` and file2.py calls
-        ``run("file3.py")``, loading file3.py first.
-        This recursive load situation can be checked on console.
-        Please don't make circular loading situation.
-
-        Note:
-            We recommend creating ``.drawlib`` directory and put all python files which are loaded.
-            Each drawing python file need to declare only ``run(<path_to_.drawlib>)``.
-
-        Strongly recommend ``auto_clear=True`` when specifying directory.
-        If user code doesn't call ``clear()``,
-        canvas state is shared between python files.
-        It means 2nd draw can contain 1st draw results.
-        Default value of ``auto_clear`` is True.
-
-        Args:
-            file_or_directory: run target. relative to user script path.
-            auto_clear(optional): call ``clear()`` method between running each python files.
-
-        Returns:
-            None
-
-        """
-
-        path = get_script_relative_path(file_or_directory)
-        if not os.path.exists(path):
-            raise ValueError(f'"{path}" does not exist')
-
-        if os.path.isfile(path):
-            if not path.endswith(".py"):
-                raise ValueError(f'Unable to run "{path}"')
-            self._load_file(path, auto_clear)
-        else:
-            self._load_directory(path, auto_clear)
-
-    def _load_file(self, path: str, auto_clear: bool):
-        self._load_stack += 1
-        indent = " " * (self._load_stack - 1) * self._INDENT_SIZE
-        logger.info(f"{indent}---")
-        logger.info(f"{indent}Execute file")
-        self._exec_module(path, auto_clear)
-        logger.info(f"{indent}End")
-        logger.info(f"{indent}---")
-        self._load_stack -= 1
-
-    def _load_directory(self, path: str, auto_clear: bool):
-        self._load_stack += 1
-        indent = " " * (self._load_stack - 1) * self._INDENT_SIZE
-        logger.info(f"{indent}---")
-        logger.info(f"{indent}Execute files under: {path}")
-        file_paths = self._get_python_files(path)
-        for file_path in file_paths:
-            self._exec_module(file_path, auto_clear)
-        logger.info(f"{indent}End")
-        logger.info(f"{indent}---")
-        self._load_stack -= 1
-
-    def _get_python_files(self, directory: str) -> List[str]:
-        python_files: List[str] = []
-        for root, _, files in os.walk(directory):
-            for file in files:
-                if file.endswith(".py"):
-                    file_path = os.path.join(root, file)
-                    python_files.append(file_path)
-
-        return sorted(python_files, key=lambda path: path.count(os.sep))
-
-    def _exec_module(self, file_path: str, auto_clear: bool) -> None:
-        """write docstring later"""
-
-        # run only 1 time.
-        # don't move .add() to bottom. It makes loop
-        if file_path in self._executed_files:
-            return
-        self._executed_files.add(file_path)
-
-        mspec = importlib.util.spec_from_file_location(
-            name="dynamically_loaded_module",
-            location=file_path,
-        )
-        if mspec is None:
-            # need to investigate what situation
-            return
-        module = importlib.util.module_from_spec(mspec)
-
-        try:
-            if auto_clear:
-                # clear previous module's drawing status
-                clear()
-
-            # call module for drawing
-            indent = " " * (self._load_stack - 1) * self._INDENT_SIZE
-            logger.info(f"{indent} - {file_path}")
-            mspec.loader.exec_module(module)  # type: ignore[union-attr]
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            file, line, _, _ = traceback.extract_tb(e.__traceback__)[-1]
-            logger.critical(f'{type(e).__name__} at file:"{file}", line:"{line}"')
-            logger.critical(str(e))
-            logger.debug("")
-            logger.debug(traceback.format_exc())
-            sys.exit(1)
-
-
-executer = DrawlibExecuter()
-dexec = executer.dexec