fix: bugs

pocketutils/misc/fancy_loguru.py

@@ -26,21 +26,20 @@
     Generic,
     Mapping,
     Optional,
+    Sequence,
     TextIO,
+    Type,
     TypeVar,
     Union,
-    Type,
-    Sequence,
 )
 
+import loguru._defaults as _defaults
+
 # noinspection PyProtectedMember
 import regex
 from loguru import logger
-import loguru._defaults as _defaults
 
 # noinspection PyProtectedMember
-from loguru._logger import Logger
-
 # noinspection PyProtectedMember
 from loguru._logger import Logger
 
@@ -78,7 +77,7 @@ def FMT(record: Mapping[str, Any]) -> str:
     @classmethod
     def plain(cls, *, fmt: str = _FMT) -> Callable[[Mapping[str, Any]], str]:
         def FMT(record: Mapping[str, Any]) -> str:
-            return fmt.replace("[EXTRA]", "")
+            return fmt.replace("[EXTRA]", "") + os.linesep
 
         return FMT
 
@@ -254,7 +253,7 @@ class FancyLoguru(Generic[T]):
     def __init__(self, log: T = logger):
         self._levels = dict(FancyLoguruDefaults.levels_built_in)
         self._logger = log
-        self._main = None
+        self._main: _HandlerInfo = None
         self._paths = {}
         self._aliases = dict(FancyLoguruDefaults.aliases)
 
@@ -326,7 +325,7 @@ def init(
         if intercept:
             # noinspection PyArgumentList
             logging.basicConfig(handlers=[InterceptHandler()], level=0, encoding="utf-8")
-        self.logger.remove(None)  # get rid of the built-in handler
+        logger.remove(None)  # get rid of the built-in handler
         self.config_main(level=level, sink=sink, fmt=fmt)
         return self
 
@@ -416,14 +415,24 @@ def remove_path(self, path: Path) -> __qualname__:
     def add_path(
         self,
         path: Path,
-        level: str = FancyLoguruDefaults.level,
+        level: str = _SENTINEL,
         *,
-        fmt: str = FancyLoguruDefaults.fmt_built_in,
+        fmt: str = _SENTINEL,
     ) -> __qualname__:
+        if level is _SENTINEL and self._main is None:
+            level = FancyLoguruDefaults.level
+        elif level is _SENTINEL:
+            level = self._main.level
         level = level.upper()
+        if fmt is _SENTINEL and self._main is None:
+            fmt = FancyLoguruDefaults.fmt_built_in
+        elif fmt is _SENTINEL:
+            fmt = self._main.fmt
+        if isinstance(fmt, str):
+            fmt = FormatFactory.with_extras(fmt=fmt)
         ell = self._levels[level]
         info = LogSinkInfo.guess(path)
-        x = logger.add(
+        x = self._logger.add(
             str(info.base),
             format=fmt,
             level=level,
@@ -465,8 +474,8 @@ def from_cli(
             path_level = "DEBUG" if match.group(1) is None else match.group(1)
             path = Path(match.group(2))
             self.add_path(path, path_level)
-            self.logger.info(f"Added logger to {path} at level {path_level}")
-        self.logger.info(f"Set main log level to {main}")
+            logger.info(f"Added logger to {path} at level {path_level}")
+        logger.info(f"Set main log level to {main}")
         return self
 
     __call__ = from_cli
@@ -495,7 +504,6 @@ class LoggerWithCautionAndNotice(LoggerWithNotice, LoggerWithCaution, metaclass=
 class FancyLoguruExtras:
     @classmethod
     def rewire_streams_to_utf8(cls) -> None:
-        # we warn the user about this in the docs!
         sys.stderr.reconfigure(encoding="utf-8")
         sys.stdout.reconfigure(encoding="utf-8")
         sys.stdin.reconfigure(encoding="utf-8")

pocketutils/misc/resources.py

@@ -10,15 +10,14 @@
 from pocketutils.core.chars import Chars
 from pocketutils.core.dot_dict import NestedDotDict
 from pocketutils.core.exceptions import (
+    DirDoesNotExistError,
     FileDoesNotExistError,
     MissingResourceError,
     PathExistsError,
-    DirDoesNotExistError,
 )
 from pocketutils.tools.common_tools import CommonTools
-from pocketutils.tools.unit_tools import UnitTools
 from pocketutils.tools.filesys_tools import FilesysTools
-
+from pocketutils.tools.unit_tools import UnitTools
 
 _logger = logging.getLogger("pocketutils")
 

pocketutils/misc/typer_utils.py

@@ -2,46 +2,42 @@
 
 import inspect
 from inspect import cleandoc
-from typing import Optional, TypeVar, Mapping
+from typing import Generic, Mapping, Optional, Type, TypeVar
 
 import typer
-from typer.models import CommandInfo, ParameterInfo, OptionInfo
+from typer.models import ArgumentInfo, CommandInfo, OptionInfo, ParameterInfo
 
 T = TypeVar("T", covariant=True)
+A = TypeVar("A", bound=ParameterInfo)
 
 
-class _Args:
-    @classmethod
-    def _arg(
-        cls,
+class _Arg(Generic[A]):
+    def __init__(self, a: Type[A]):
+        self.__a = a
+
+    def __arg(
+        self,
         doc: str,
-        *names,
+        *names: str,
         default: Optional[T] = None,
-        pos: bool = False,
         **kwargs,
     ):
-        kwargs = dict(
-            help=cleandoc(doc),
-            **kwargs,
-            allow_dash=True,
-        )
-        if pos:
-            return typer.Argument(default, **kwargs)
+        args = dict(allow_dash=True, help=cleandoc(doc), **kwargs)
+        if self.__a is OptionInfo:
+            return typer.Option(default, *names, **args)
         else:
-            return typer.Option(default, *names, **kwargs)
+            return typer.Argument(default, **args)
 
-    @classmethod
-    def _path(
-        cls,
+    def __path(
+        self,
         doc: str,
         *names,
         default: Optional[str],
         f: bool,
         d: bool,
         out: bool,
-        pos: bool,
         **kwargs,
-    ):
+    ) -> A:
         kwargs = {
             **dict(
                 exists=not out,
@@ -52,109 +48,53 @@ def _path(
             ),
             **kwargs,
         }
-        return _Args._arg(doc, *names, default=default, pos=pos, **kwargs)
-
-
-class Arg(_Args):
-    @classmethod
-    def _arg(cls, doc: str, *, default: Optional[T] = None, **kwargs):
-        super()._arg(doc, default=default, pos=True, **kwargs)
-
-    @classmethod
-    def _path(cls, doc: str, *, default: Optional[str], f: bool, d: bool, out: bool, **kwargs):
-        super()._path(doc, defualt=default, f=f, d=d, out=out, pos=True, **kwargs)
-
-    @classmethod
-    def out_file(cls, doc: str, *, default: Optional[str] = None, **kwargs):
-        return cls._path(doc, default=default, f=True, d=False, out=True, **kwargs)
-
-    @classmethod
-    def out_dir(cls, doc: str, *, default: Optional[str] = None, **kwargs):
-        return cls._path(doc, default=default, f=True, d=True, out=True, **kwargs)
-
-    @classmethod
-    def out_path(cls, doc: str, *, default: Optional[str] = None, **kwargs):
-        return cls._path(doc, default=default, f=True, d=True, out=False, **kwargs)
-
-    @classmethod
-    def in_file(cls, doc: str, *, default: Optional[str] = None, **kwargs):
-        return cls._path(doc, default=default, f=True, d=False, out=False, **kwargs)
+        return self.__arg(doc, *names, default=default, **kwargs)
 
-    @classmethod
-    def in_dir(cls, doc: str, *, default: Optional[str] = None, **kwargs):
-        return cls._path(doc, default=default, f=False, d=True, out=False, **kwargs)
-
-    @classmethod
-    def in_path(cls, doc: str, *, default: Optional[str] = None, **kwargs):
-        return cls._path(doc, default=default, f=True, d=True, out=False, **kwargs)
-
-    @classmethod
-    def val(cls, doc: str, *, default: Optional[T] = None, **kwargs):
-        return cls._arg(doc, default=default, **kwargs)
-
-
-class Opt(_Args):
-    @classmethod
-    def _arg(cls, doc: str, *names: str, default: Optional[T] = None, **kwargs):
-        super()._arg(doc, default=default, **kwargs)
-
-    @classmethod
-    def _path(
-        cls, doc: str, *names: str, default: Optional[str], f: bool, d: bool, out: bool, **kwargs
-    ):
-        super()._path(doc, defualt=default, f=f, d=d, out=out, **kwargs)
+    def out_file(self, doc: str, *names, default: Optional[str] = None, **kwargs) -> A:
+        return self.__path(doc, *names, default=default, f=True, d=False, out=True, **kwargs)
 
-    @classmethod
-    def out_file(cls, doc: str, *names, default: Optional[str] = None, **kwargs):
-        return _Args._path(doc, *names, default=default, f=True, d=False, out=True, **kwargs)
-
-    @classmethod
-    def out_dir(cls, doc: str, *names, default: Optional[str] = None, **kwargs):
-        return _Args._path(doc, *names, default=default, f=True, d=True, out=True, **kwargs)
+    def out_dir(self, doc: str, *names, default: Optional[str] = None, **kwargs) -> A:
+        return self.__path(doc, *names, default=default, f=True, d=True, out=True, **kwargs)
 
-    @classmethod
-    def out_path(cls, doc: str, *names, default: Optional[str] = None, **kwargs):
-        return _Args._path(
+    def out_path(self, doc: str, *names, default: Optional[str] = None, **kwargs) -> A:
+        return self.__path(
             doc,
             *names,
             default=default,
             f=True,
             d=True,
             out=False,
-            pos=False,
             exists=False,
             **kwargs,
         )
 
-    @classmethod
-    def in_file(cls, doc: str, *names, default: Optional[str] = None, **kwargs):
-        return _Args._path(doc, *names, default=default, f=True, d=False, out=False, **kwargs)
+    def in_file(self, doc: str, *names, default: Optional[str] = None, **kwargs) -> A:
+        return self.__path(doc, *names, default=default, f=True, d=False, out=False, **kwargs)
 
-    @classmethod
-    def in_dir(cls, doc: str, *names, default: Optional[str] = None, **kwargs):
-        return _Args._path(doc, *names, default=default, f=False, d=True, out=False, **kwargs)
+    def in_dir(self, doc: str, *names, default: Optional[str] = None, **kwargs) -> A:
+        return self.__path(doc, *names, default=default, f=False, d=True, out=False, **kwargs)
 
-    @classmethod
-    def in_path(cls, doc: str, *names, default: Optional[str] = None, **kwargs):
-        return _Args._path(
+    def in_path(self, doc: str, *names, default: Optional[str] = None, **kwargs) -> A:
+        return self.__path(
             doc,
             *names,
             default=default,
             f=True,
             d=True,
             out=False,
-            pos=False,
             exists=False,
             **kwargs,
         )
 
-    @classmethod
-    def val(cls, doc: str, *names, default: Optional[T] = None, **kwargs):
-        return _Args._arg(doc, *names, default=default, **kwargs)
+    def val(self, doc: str, *names, default: Optional[T] = None, **kwargs) -> A:
+        return self.__arg(doc, *names, default=default, **kwargs)
 
-    @classmethod
-    def flag(cls, doc: str, *names, **kwargs):
-        return _Args._arg(doc, *names, default=False, **kwargs)
+    def flag(self, doc: str, *names, **kwargs) -> A:
+        return self.__arg(doc, *names, default=False, **kwargs)
+
+
+Arg: _Arg[ArgumentInfo] = _Arg(ArgumentInfo)
+Opt: _Arg[OptionInfo] = _Arg(OptionInfo)
 
 
 class TyperUtils:

pocketutils/tools/all_tools.py

@@ -1,8 +1,8 @@
-from pocketutils.tools.loop_tools import LoopTools
 from pocketutils.tools.call_tools import CallTools
 from pocketutils.tools.common_tools import CommonTools
 from pocketutils.tools.console_tools import ConsoleTools
 from pocketutils.tools.filesys_tools import FilesysTools
+from pocketutils.tools.loop_tools import LoopTools
 from pocketutils.tools.numeric_tools import NumericTools
 from pocketutils.tools.path_tools import PathTools
 from pocketutils.tools.program_tools import ProgramTools

pocketutils/tools/filesys_tools.py

@@ -4,33 +4,33 @@
 import locale
 import logging
 import os
+import pathlib
 import platform
 import shutil
 import socket
+import stat
 import struct
 import sys
-import stat
 import tempfile
 from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from getpass import getuser
 from pathlib import Path, PurePath
-import pathlib
 from typing import Any, Generator, Iterable, Mapping, Optional, Sequence, SupportsBytes, Type, Union
 
-from defusedxml import ElementTree
 import numpy as np
 import orjson
 import pandas as pd
 import regex
+from defusedxml import ElementTree
 
 from pocketutils.core.exceptions import (
     AlreadyUsedError,
     ContradictoryRequestError,
+    DirDoesNotExistError,
     FileDoesNotExistError,
     ParsingError,
-    DirDoesNotExistError,
 )
 from pocketutils.core.input_output import OpenMode, PathLike, Writeable
 from pocketutils.core.web_resource import *

pocketutils/tools/unit_tools.py

@@ -1,6 +1,6 @@
 import logging
 import math
-from datetime import datetime, date, timedelta
+from datetime import date, datetime, timedelta
 from typing import Optional, SupportsFloat, Tuple, Union
 
 import regex