justin-utils 0.1.0__py3-none-any.whl

justin_utils/cd.py

@@ -0,0 +1,18 @@
+import os
+from contextlib import contextmanager
+from pathlib import Path
+
+
+@contextmanager
+def cd(new_path: Path):
+    assert new_path.exists()
+    assert new_path.is_dir()
+
+    previous_path = Path.cwd()
+
+    os.chdir(str(new_path.expanduser()))
+
+    try:
+        yield
+    finally:
+        os.chdir(str(previous_path))

justin_utils/cli.py

@@ -0,0 +1,143 @@
+from abc import abstractmethod
+from argparse import ArgumentParser, Namespace
+from dataclasses import dataclass, asdict
+from enum import Enum
+from typing import Any, Iterable, Dict, ClassVar, Type, Callable, List, TypeVar
+
+from justin_utils.util import is_distinct
+
+Context = Any
+
+T = TypeVar("T")
+
+
+@dataclass
+class Parameter:
+    class Action(str, Enum):
+        STORE_TRUE = "store_true"
+
+    name: str = None
+    flags: Iterable[str] = None
+    nargs: str = None
+    default: Any = None
+    action: Action = None
+    type: Type | Callable[[str], T] = None
+    choices: Iterable[T] = None
+
+    not_kw_fields: ClassVar[Iterable[str]] = [
+        "name",
+        "flags",
+    ]
+
+    def __post_init__(self) -> None:
+        if self.flags is None:
+            self.flags = ()
+        else:
+            self.flags = tuple(self.flags)
+
+        if self.action is not None:
+            self.action = self.action.value
+
+    @property
+    def name_or_flags(self) -> Iterable[str]:
+        # noinspection PyTypeChecker
+        return tuple(i for i in (self.name,) + self.flags if i)
+
+    @property
+    def params(self) -> Dict[str, Any]:
+        return {k: v for k, v in asdict(self).items() if k not in Parameter.not_kw_fields and v}
+
+
+class Action:
+    def configure_subparser(self, subparser: ArgumentParser) -> None:
+        pass
+
+    @property
+    def parameters(self) -> List[Parameter]:
+        return []
+
+    @abstractmethod
+    def perform(self, args: Namespace, context: Context) -> None:
+        pass
+
+
+class Command:
+    def __init__(self, name: str, actions: Iterable[Action], allowed_same_parameters: Iterable[str] = ()) -> None:
+        super().__init__()
+
+        name = name.strip()
+
+        assert " " not in name
+
+        params_set = set()
+
+        for action in actions:
+            for param in action.parameters:
+                param_name = param.name_or_flags
+
+                assert param_name not in params_set or any(i in allowed_same_parameters for i in param_name)
+
+                params_set.add(param_name)
+
+        self.__name = name
+        self.__actions = actions
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    def configure_parser(self, parser_adder) -> None:
+        subparser: ArgumentParser = parser_adder.add_parser(self.__name)
+
+        self.configure_subparser(subparser)
+
+        self.__setup_callback(subparser)
+
+    def configure_subparser(self, subparser: ArgumentParser) -> None:
+        params_set = set()
+
+        for action in self.__actions:
+            for parameter in action.parameters:
+                if parameter.name_or_flags in params_set:
+                    continue
+
+                subparser.add_argument(*parameter.name_or_flags, **parameter.params)
+                params_set.add(parameter.name_or_flags)
+
+            action.configure_subparser(subparser)
+
+    def __setup_callback(self, parser: ArgumentParser) -> None:
+        parser.set_defaults(command=self)
+
+    def __call__(self, args: Namespace, context: Context) -> None:
+        for action in self.__actions:
+            action.perform(args, context)
+
+
+class App:
+    def __init__(self, commands: Iterable[Command], context: Context = None) -> None:
+        super().__init__()
+
+        assert is_distinct([command.name for command in commands])
+
+        self.__commands = commands
+        self.__context = context
+
+    def run(self, args: Iterable[str] = None) -> None:
+        parser = ArgumentParser()
+
+        parser_adder = parser.add_subparsers()
+
+        for command in self.__commands:
+            command.configure_parser(parser_adder)
+
+        namespace = parser.parse_args(args)
+
+        if not hasattr(namespace, "command"):
+            print("No parameters is bad")
+        elif not namespace.command:
+            print("No command found.")
+        elif not isinstance(namespace.command, Command):
+            print("Wrong command class")
+        else:
+            namespace.command(namespace, self.__context)

justin_utils/data.py

@@ -0,0 +1,137 @@
+from datetime import timedelta
+from enum import Enum
+from functools import cache
+from typing import List, Optional, Union
+
+
+class DataSize:
+    class Unit(Enum):
+        BYTE = (2 ** 0, "B")
+        KILOBYTE = (2 ** 10, "KB")
+        MEGABYTE = (2 ** 20, "MB")
+        GIGABYTE = (2 ** 30, "GB")
+
+        def __init__(self, size: int, acronym: str) -> None:
+            super().__init__()
+
+            self.size = size
+            self.acronym = acronym
+
+        @staticmethod
+        @cache
+        def sorted_units() -> List['DataSize.Unit']:
+            return sorted([
+                DataSize.Unit.BYTE,
+                DataSize.Unit.KILOBYTE,
+                DataSize.Unit.MEGABYTE,
+                DataSize.Unit.GIGABYTE,
+            ],
+                key=lambda u: u.size,
+                reverse=True)
+
+        @staticmethod
+        def for_value(value: int) -> 'DataSize.Unit':
+            for unit in DataSize.Unit.sorted_units():
+                if value > unit.size:
+                    return unit
+
+            return DataSize.Unit.BYTE
+
+    def __init__(self, size_in_bytes: int) -> None:
+        super().__init__()
+
+        assert isinstance(size_in_bytes, int)
+
+        self.__bytes = size_in_bytes
+
+    def __str__(self) -> str:
+        return self.formatted()
+
+    def formatted(self) -> str:
+        unit = DataSize.Unit.for_value(self.__bytes)
+
+        converted_size = round(self.__bytes / unit.size, 2)
+
+        result = f"{converted_size:.2f} {unit.acronym}"
+
+        return result
+
+    def canonic_value(self) -> int:
+        return round(self.__as_unit(DataSize.Unit.BYTE))
+
+    def __as_unit(self, unit: Unit) -> float:
+        return self.__bytes / unit.size
+
+    def add_bytes(self, bytes_: int) -> None:
+        self.__bytes += bytes_
+
+    @classmethod
+    def __from_unit(cls, size: float, unit: Unit) -> 'DataSize':
+        return DataSize(round(size * unit.size))
+
+    @classmethod
+    def from_bytes(cls, size: int) -> 'DataSize':
+        return DataSize.__from_unit(size, DataSize.Unit.BYTE)
+
+    def __truediv__(self, other):
+        if isinstance(other, timedelta):
+            return DataSpeed(self, other)
+        elif isinstance(other, DataSpeed):
+            speed_canonic = other.canonic_value()
+
+            if speed_canonic is None:
+                return None
+
+            self_canonic = self.canonic_value()
+
+            time_in_seconds = self_canonic / speed_canonic
+
+            return timedelta(seconds=time_in_seconds)
+        else:
+            assert False
+
+    def __sub__(self, other) -> 'DataSize':
+        if isinstance(other, DataSize):
+            return DataSize.from_bytes(self.canonic_value() - other.canonic_value())
+        else:
+            assert False
+
+    def __lt__(self, other: Union['DataSize', int]) -> bool:
+        if isinstance(other, DataSize):
+            other = other.__bytes
+
+        return self.__bytes < other
+
+
+class DataSpeed:
+    def __init__(self, amount: DataSize, time: timedelta) -> None:
+        super().__init__()
+
+        assert isinstance(amount, DataSize)
+        assert isinstance(time, timedelta)
+
+        self.__amount = amount
+        self.__time = time
+
+    def __str__(self) -> str:
+        return self.formatted()
+
+    def formatted(self) -> str:
+        speed = self.canonic_value()
+
+        if speed is None:
+            return "N/A"
+
+        unit = DataSize.Unit.for_value(round(speed))
+
+        converted_size = speed / unit.size
+
+        result = f"{converted_size:.2f} {unit.acronym}/s"
+
+        return result
+
+    def canonic_value(self) -> Optional[float]:
+        if self.__time.total_seconds() == 0:
+            return None
+
+        return self.__amount.canonic_value() / self.__time.total_seconds()

justin_utils/exif.py

@@ -0,0 +1,117 @@
+from abc import abstractmethod, ABC
+from datetime import datetime
+from functools import cache
+from pathlib import Path
+from typing import Iterable
+from typing_extensions import Self
+
+from exif import Image  # type: ignore[import-untyped]
+
+from PIL import ExifTags
+from PIL.Image import Exif as PilExif
+from PIL import Image as ImageModule
+
+class Exif(ABC):
+    @property
+    @abstractmethod
+    def date_taken(self) -> datetime:
+        pass
+
+    def __lt__(self, other: 'Exif') -> bool:
+        return self.date_taken < other.date_taken
+
+    @classmethod
+    @abstractmethod
+    def from_path(cls, path: Path) -> Self:
+        pass
+
+
+class PillowExif(Exif):
+    __reverse_mapping = {v: k for k, v in ExifTags.TAGS.items()}
+
+    @property
+    @cache
+    def date_taken(self) -> datetime:
+        date_str = self.__get_tag_value("DateTimeOriginal") or self.__get_tag_value("DateTime")
+        assert date_str is not None
+        return datetime.strptime(date_str, "%Y:%m:%d %H:%M:%S")
+
+    def __get_tag_value(self, tag: str) -> str | None:
+        return self.source_exif.get(PillowExif.__reverse_mapping[tag])
+
+    def __init__(self, exif: PilExif) -> None:
+        super().__init__()
+
+        self.source_exif = exif
+
+    @classmethod
+    def from_path(cls, path: Path) -> Self:
+        return cls(ImageModule.open(path).getexif())
+
+
+class NativeExif(Exif):
+    @property
+    @cache
+    def date_taken(self) -> datetime:
+        if hasattr(self.source_exif, "datetime_original"):
+            return datetime.strptime(
+                self.source_exif.datetime_original,
+                "%Y:%m:%d %H:%M:%S"
+            )
+        elif hasattr(self.source_exif, "datetime_digitized"):
+            return datetime.strptime(
+                self.source_exif.datetime_digitized,
+                "%Y:%m:%d %H:%M:%S"
+            )
+        else:
+            assert False
+
+    def __init__(self, exif: Image) -> None:
+        super().__init__()
+
+        self.source_exif = exif
+
+    @classmethod
+    def from_path(cls, path: Path) -> Self:
+        with path.open("rb") as image_file:
+            my_image = Image(image_file)
+
+            return cls(my_image)
+
+
+def parse_exif(path: Path) -> Exif | None:
+    if path is None:
+        return None
+
+    if path.is_dir():
+        return None
+
+    suffix = path.suffix.lower()
+
+    exif_class: type[PillowExif] | type[NativeExif]
+
+    if suffix in [".nef", ".dng", ]:
+        exif_class = PillowExif
+    elif suffix in [".jpg", ]:
+        exif_class = NativeExif
+    else:
+        return None
+
+    return exif_class.from_path(path)
+
+
+def exif_sorted(seq: Iterable[Path]) -> Iterable[Path]:
+    class Comparator:
+        def __init__(self, path: Path) -> None:
+            super().__init__()
+
+            self.exif = parse_exif(path)
+            self.name = path.name
+
+        def __lt__(self, other: 'Comparator') -> bool:
+            if other.exif and self.exif:
+                return self.exif.date_taken < other.exif.date_taken
+
+            return self.name < other.name
+
+    return sorted(seq, key=Comparator)