plexus-python-common 1.0.7__py3-none-any.whl

plexus/common/utils/s3utils.py

@@ -0,0 +1,118 @@
+import contextlib
+import functools
+import os.path
+from collections.abc import Callable
+from pathlib import Path
+from typing import Literal
+
+from cloudpathlib import CloudPath, S3Client, S3Path
+from rich.progress import BarColumn, DownloadColumn, Progress, TaskID, TextColumn, TransferSpeedColumn
+
+__all__ = [
+    "TransferCallbackS3Client",
+    "make_progress_callback",
+    "make_progressed_s3_client",
+]
+
+TransferDirection = Literal["download", "upload"]
+TransferState = Literal["start", "update", "stop"]
+
+
+@contextlib.contextmanager
+def make_transfer_callback(
+    callback: Callable[[CloudPath, TransferDirection, TransferState, int], None],
+    path: Path | CloudPath,
+    direction: TransferDirection,
+):
+    if callback is None:
+        yield None
+        return
+
+    callback(path, direction, "start", 0)
+    try:
+        yield functools.partial(callback, path, direction, "update")
+    finally:
+        callback(path, direction, "stop", 0)
+
+
+class TransferCallbackS3Client(S3Client):
+    def __init__(
+        self,
+        *args,
+        transfer_callback: Callable[[CloudPath, TransferDirection, TransferState, int], None],
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.transfer_callback = transfer_callback
+
+    def _download_file(self, cloud_path: S3Path, local_path: str | os.PathLike) -> Path:
+        local_path = Path(local_path)
+
+        obj = self.s3.Object(cloud_path.bucket, cloud_path.key)
+
+        with make_transfer_callback(self.transfer_callback, cloud_path, "download") as callback:
+            obj.download_file(
+                str(local_path),
+                Config=self.boto3_transfer_config,
+                ExtraArgs=self.boto3_dl_extra_args,
+                Callback=callback,
+            )
+        return local_path
+
+    def _upload_file(self, local_path: str | os.PathLike, cloud_path: S3Path) -> S3Path:
+        local_path = Path(local_path)
+
+        obj = self.s3.Object(cloud_path.bucket, cloud_path.key)
+
+        extra_args = self.boto3_ul_extra_args.copy()
+
+        if self.content_type_method is not None:
+            content_type, content_encoding = self.content_type_method(str(local_path))
+            if content_type is not None:
+                extra_args["ContentType"] = content_type
+            if content_encoding is not None:
+                extra_args["ContentEncoding"] = content_encoding
+
+        with make_transfer_callback(self.transfer_callback, local_path, "upload") as callback:
+            obj.upload_file(
+                str(local_path),
+                Config=self.boto3_transfer_config,
+                ExtraArgs=extra_args,
+                Callback=callback,
+            )
+        return cloud_path
+
+
+def make_progress_callback(progress: Progress) -> Callable[[CloudPath, TransferDirection, TransferState, int], None]:
+    task_ids: dict[Path | CloudPath, TaskID] = {}
+
+    def progress_callback(path: Path | CloudPath, direction: TransferDirection, state: TransferState, bytes_sent: int):
+        if state == "start":
+            size = path.stat().st_size
+            task_ids[path] = progress.add_task(direction, total=size, filename=path.name)
+        elif state == "stop":
+            if path in task_ids:
+                progress.remove_task(task_ids[path])
+                del task_ids[path]
+        else:
+            progress.update(task_ids[path], advance=bytes_sent)
+
+    return progress_callback
+
+
+@contextlib.contextmanager
+def make_progressed_s3_client(aws_access_key_id: str, aws_secret_access_key: str, endpoint_url: str):
+    aws_access_key_id = aws_access_key_id or os.environ.get("AWS_ACCESS_KEY_ID")
+    aws_secret_access_key = aws_secret_access_key or os.environ.get("AWS_SECRET_ACCESS_KEY")
+    endpoint_url = endpoint_url or os.environ.get("AWS_ENDPOINT_URL")
+
+    with Progress(
+        TextColumn("[blue]{task.fields[filename]}"),
+        BarColumn(),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+    ) as progress:
+        yield TransferCallbackS3Client(aws_access_key_id=aws_access_key_id,
+                                       aws_secret_access_key=aws_secret_access_key,
+                                       endpoint_url=endpoint_url,
+                                       transfer_callback=make_progress_callback(progress))

plexus/common/utils/shutils.py

@@ -0,0 +1,234 @@
+import os
+from collections.abc import Callable, Generator
+
+import pyparsing as pp
+from iker.common.utils.funcutils import singleton
+from iker.common.utils.strutils import is_blank
+
+__all__ = [
+    "volume_template_parser",
+    "make_volume_parser",
+    "make_volume_generator",
+    "collect_volumed_filenames",
+    "populate_volumed_filenames",
+]
+
+
+@singleton
+def volume_template_parser() -> pp.ParserElement:
+    lbrace_token = pp.Char("{")
+    rbrace_token = pp.Char("}")
+    colon_token = pp.Char(":")
+    chars_token = pp.Regex(r"[^{}]*")
+    name_token = pp.Regex(r"[a-z][a-z0-9_]*")
+
+    parser_expr = pp.Combine(lbrace_token +
+                             (name_token("name") + colon_token)[0, 1] +
+                             chars_token("prefix") +
+                             lbrace_token +
+                             rbrace_token +
+                             chars_token("suffix") +
+                             rbrace_token)
+    return parser_expr
+
+
+def make_trivial_volume_func() -> Callable[[str], int]:
+    """
+    Creates a trivial volume function that generates unique integer volumes for each name.
+
+    The function maintains a generator for each unique name and increments the volume
+    value each time the function is called with the same name. If a new name is provided,
+    a new generator is created for that name.
+
+    :return: a callable function that takes a name (str) and returns the next integer volume.
+    """
+
+    def trivial_volume_generator() -> Generator[int, None, None]:
+        volume = 0
+        while True:
+            yield volume
+            volume += 1
+
+    volume_generators = {}
+
+    def volume_func(name: str) -> int:
+        if name not in volume_generators:
+            volume_generators[name] = trivial_volume_generator()
+        return next(volume_generators[name])
+
+    return volume_func
+
+
+def make_volume_parser(template: str) -> Callable[[str], dict[str, int]]:
+    """
+    Creates a parser function for extracting volume information from filenames based on a given template.
+
+    The template defines the structure of filenames, including placeholders for volume values.
+    The returned parser function takes a filename as input and extracts the volume values
+    as a dictionary where the keys are the placeholder names and the values are the corresponding integers.
+
+    :param template: a string template defining the filename structure with placeholders for volumes.
+                     Placeholders are enclosed in double curly braces `{{}}` and can optionally include
+                     a name, a prefix, and a suffix (e.g., `{name:prefix{}suffix}`).
+
+    :return: a callable function that takes a filename (str) and returns a dictionary mapping
+             placeholder names to their extracted integer values.
+
+    :raises ValueError: if the template is invalid or cannot be parsed.
+    """
+    try:
+        scan_result = list(volume_template_parser().scan_string(template, overlap=False))
+    except pp.ParseException as e:
+        raise ValueError(f"bad template '{template}'") from e
+
+    volume_token = pp.Regex(r"\d+")
+
+    parser_expr = pp.Literal("")
+    prev_end_pos = 0
+    index = 0
+    for parse_results, begin_pos, end_pos in scan_result:
+        if prev_end_pos < begin_pos:
+            parser_expr = parser_expr + pp.Literal(template[prev_end_pos:begin_pos])
+        prefix = parse_results.get("prefix")
+        suffix = parse_results.get("suffix")
+        name = parse_results.get("name")
+        if is_blank(name):
+            name = str(index)
+            index += 1
+        if not is_blank(prefix):
+            parser_expr = parser_expr + pp.Literal(prefix)
+        parser_expr = parser_expr + volume_token(name)
+        if not is_blank(suffix):
+            parser_expr = parser_expr + pp.Literal(suffix)
+        prev_end_pos = end_pos
+    if prev_end_pos < len(template):
+        parser_expr = parser_expr + pp.Literal(template[prev_end_pos:])
+
+    parser_expr = pp.Combine(pp.StringStart() + parser_expr + pp.StringEnd())
+
+    def parser(s: str) -> dict[str, int]:
+        parser_results = parser_expr.parse_string(s, parse_all=True)
+
+        volumes = {}
+        for name in parser_results.keys():
+            volume = parser_results.get(name)
+            volumes[name] = int(volume)
+
+        return volumes
+
+    return parser
+
+
+def make_volume_generator(template: str) -> Callable[[Callable[[str], int]], tuple[str, dict[str, int]]]:
+    """
+    Creates a generator function for producing filenames and their associated volume values
+    based on a given template.
+
+    The template defines the structure of filenames, including placeholders for volume values.
+    The returned generator function takes a volume function as input, which determines the
+    volume values for each placeholder, and produces filenames with the corresponding volumes.
+
+    :param template: a string template defining the filename structure with placeholders for volumes.
+                     Placeholders are enclosed in double curly braces `{{}}` and can optionally include
+                     a name, a prefix, and a suffix (e.g., `{name:prefix{}suffix}`).
+
+    :return: a callable generator function that takes a volume function (Callable[[str], int]) as input
+             and returns a tuple containing the generated filename (str) and a dictionary mapping
+             placeholder names to their corresponding volume values (dict[str, int]).
+
+    :raises ValueError: if the template is invalid or cannot be parsed.
+    """
+    try:
+        scan_result = list(volume_template_parser().scan_string(template, overlap=False))
+    except pp.ParseException as e:
+        raise ValueError(f"bad template '{template}'") from e
+
+    def generator(volume_func: Callable[[str], int]) -> tuple[str, dict[str, int]]:
+        volumes = {}
+
+        volume_expr = ""
+        prev_end_pos = 0
+        index = 0
+        for parse_results, begin_pos, end_pos in scan_result:
+            if prev_end_pos < begin_pos:
+                volume_expr = volume_expr + template[prev_end_pos:begin_pos]
+            prefix = parse_results.get("prefix")
+            suffix = parse_results.get("suffix")
+            name = parse_results.get("name")
+            if is_blank(name):
+                name = str(index)
+                index += 1
+            if not is_blank(prefix):
+                volume_expr = volume_expr + prefix
+            volumes[name] = int(volume_func(name))
+            volume_expr = volume_expr + str(volumes[name])
+            if not is_blank(suffix):
+                volume_expr = volume_expr + suffix
+            prev_end_pos = end_pos
+        if prev_end_pos < len(template):
+            volume_expr = volume_expr + template[prev_end_pos:]
+
+        return volume_expr, volumes
+
+    return generator
+
+
+def collect_volumed_filenames(template: str) -> Generator[tuple[str, dict[str, int]], None, None]:
+    """
+    Collects filenames in a folder that match a given template and extracts their volume information.
+
+    The template defines the structure of filenames, including placeholders for volume values.
+    This function scans the folder containing the template and attempts to parse filenames
+    to extract volume values based on the template.
+
+    :param template: a string template defining the filename structure with placeholders for volumes.
+                     Placeholders are enclosed in double curly braces `{{}}` and can optionally include
+                     a name, a prefix, and a suffix (e.g., `{name:prefix{}suffix}`).
+
+    :return: a generator yielding tuples where the first element is the full path of the filename
+             and the second element is a dictionary mapping placeholder names to their extracted
+             integer volume values.
+    """
+    folder = os.path.dirname(template)
+    basename = os.path.basename(template)
+
+    parser = make_volume_parser(basename)
+
+    for name in os.listdir(folder):
+        try:
+            volumes = parser(name)
+            yield os.path.join(folder, name), volumes
+        except pp.ParseException:
+            pass
+
+
+def populate_volumed_filenames(
+    template: str,
+    *,
+    volume_func: Callable[[str], int] = None,
+) -> Generator[tuple[str, dict[str, int]], None, None]:
+    """
+    Generates filenames and their associated volume values based on a given template.
+
+    The template defines the structure of filenames, including placeholders for volume values.
+    This function uses a volume function to generate unique volume values for each placeholder
+    and produces filenames with the corresponding volumes.
+
+    :param template: a string template defining the filename structure with placeholders for volumes.
+                     Placeholders are enclosed in double curly braces `{{}}` and can optionally include
+                     a name, a prefix, and a suffix (e.g., `{name:prefix{}suffix}`).
+    :param volume_func: a callable function that takes a placeholder name (str) and returns the next
+                        integer volume value. If not provided, a trivial volume function is used.
+
+    :return: a generator yielding tuples where the first element is the generated filename (str)
+             and the second element is a dictionary mapping placeholder names to their corresponding
+    """
+    folder = os.path.dirname(template)
+    basename = os.path.basename(template)
+
+    generator = make_volume_generator(basename)
+    volume_func = volume_func or make_trivial_volume_func()
+
+    while True:
+        name, volumes = generator(volume_func)
+        yield os.path.join(folder, name), volumes

plexus/common/utils/strutils.py

@@ -0,0 +1,285 @@
+import dataclasses
+import datetime
+import re
+from collections.abc import Callable
+
+import pyparsing as pp
+from iker.common.utils.dtutils import basic_format, dt_format, dt_parse
+from iker.common.utils.funcutils import singleton
+
+__all__ = [
+    "hex_string_pattern",
+    "hex_string_parser",
+    "snake_case_pattern",
+    "snake_case_parser",
+    "kebab_case_pattern",
+    "kebab_case_parser",
+    "dot_case_pattern",
+    "dot_case_parser",
+    "strict_relpath_pattern",
+    "strict_relpath_parser",
+    "strict_abspath_pattern",
+    "strict_abspath_parser",
+    "uuid_pattern",
+    "uuid_parser",
+    "tag_pattern",
+    "tag_parser",
+    "topic_pattern",
+    "topic_parser",
+    "vin_code_chars",
+    "vin_code_pattern",
+    "vin_code_parser",
+    "UserName",
+    "VehicleName",
+    "BagName",
+    "parse_user_name",
+    "parse_vehicle_name",
+    "parse_bag_name",
+]
+
+
+def token_check(cond: Callable[[str], bool]) -> Callable[[pp.ParseResults], bool]:
+    def cond_func(results: pp.ParseResults) -> bool:
+        token, *_ = results
+        return cond(token)
+
+    return cond_func
+
+
+def token_reparse(elem: pp.ParserElement, negate: bool = False) -> Callable[[pp.ParseResults], bool]:
+    def cond_func(results: pp.ParseResults) -> bool:
+        token, *_ = results
+        try:
+            elem.parse_string(token, parse_all=True)
+            return not negate
+        except pp.ParseException:
+            return negate
+
+    return cond_func
+
+
+def make_string_pattern(pattern: re.Pattern[str]) -> re.Pattern[str]:
+    return re.compile(rf"^{pattern.pattern}$")
+
+
+def make_string_parser(element: pp.ParserElement) -> pp.ParserElement:
+    return pp.Combine(pp.StringStart() + element + pp.StringEnd())
+
+
+lowers_regexp: re.Pattern[str] = re.compile(r"[a-z]+")
+uppers_regexp: re.Pattern[str] = re.compile(r"[A-Z]+")
+digits_regexp: re.Pattern[str] = re.compile(r"[0-9]+")
+lower_digits_regexp: re.Pattern[str] = re.compile(r"[a-z0-9]+")
+upper_digits_regexp: re.Pattern[str] = re.compile(r"[A-Z0-9]+")
+alpha_digits_regexp: re.Pattern[str] = re.compile(r"[a-zA-Z0-9]+")
+hex_digits_regexp: re.Pattern[str] = re.compile(r"[a-f0-9]+")
+lower_identifier_regexp: re.Pattern[str] = re.compile(r"[a-z][a-z0-9]*")
+upper_identifier_regexp: re.Pattern[str] = re.compile(r"[A-Z][A-Z0-9]*")
+strict_chars_regexp: re.Pattern[str] = re.compile(r"[a-zA-Z0-9._-]+")
+
+lowers_element: pp.ParserElement = pp.Regex(lowers_regexp.pattern)
+uppers_element: pp.ParserElement = pp.Regex(uppers_regexp.pattern)
+digits_element: pp.ParserElement = pp.Regex(digits_regexp.pattern)
+lower_digits_element: pp.ParserElement = pp.Regex(lower_digits_regexp.pattern)
+upper_digits_element: pp.ParserElement = pp.Regex(upper_digits_regexp.pattern)
+alpha_digits_element: pp.ParserElement = pp.Regex(alpha_digits_regexp.pattern)
+hex_digits_element: pp.ParserElement = pp.Regex(hex_digits_regexp.pattern)
+lower_identifier_element: pp.ParserElement = pp.Regex(lower_identifier_regexp.pattern)
+upper_identifier_element: pp.ParserElement = pp.Regex(upper_identifier_regexp.pattern)
+strict_chars_element: pp.ParserElement = pp.Regex(strict_chars_regexp.pattern)
+
+underscore_token: pp.ParserElement = pp.Char("_")
+hyphen_token: pp.ParserElement = pp.Char("-")
+period_token: pp.ParserElement = pp.Char(".")
+colon_token: pp.ParserElement = pp.Char(":")
+slash_token: pp.ParserElement = pp.Char("/")
+plus_token: pp.ParserElement = pp.Char("+")
+
+basic_datetime_regexp: re.Pattern[str] = re.compile(r"\d{8}T\d{6}")
+extended_datetime_regexp: re.Pattern[str] = re.compile(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}")
+
+basic_datetime_element: pp.ParserElement = pp.Regex(basic_datetime_regexp.pattern)
+extended_datetime_element: pp.ParserElement = pp.Regex(extended_datetime_regexp.pattern)
+
+number_regexp: re.Pattern[str] = re.compile(r"0|([1-9][0-9]*)")
+positive_number_regexp: re.Pattern[str] = re.compile(r"[1-9][0-9]*")
+
+number_element: pp.ParserElement = pp.Regex(number_regexp.pattern)
+positive_number_element: pp.ParserElement = pp.Regex(positive_number_regexp.pattern)
+
+snake_case_regexp: re.Pattern[str] = re.compile(
+    rf"{lower_digits_regexp.pattern}(?:_{lower_digits_regexp.pattern})*")
+kebab_case_regexp: re.Pattern[str] = re.compile(
+    rf"{lower_digits_regexp.pattern}(?:-{lower_digits_regexp.pattern})*")
+dot_case_regexp: re.Pattern[str] = re.compile(
+    rf"{lower_digits_regexp.pattern}(?:\.{lower_digits_regexp.pattern})*")
+
+snake_case_element: pp.ParserElement = pp.Combine(
+    lower_digits_element + (underscore_token + lower_digits_element)[...])
+kebab_case_element: pp.ParserElement = pp.Combine(
+    lower_digits_element + (hyphen_token + lower_digits_element)[...])
+dot_case_element: pp.ParserElement = pp.Combine(
+    lower_digits_element + (period_token + lower_digits_element)[...])
+
+uuid_regexp: re.Pattern[str] = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}")
+uuid_element: pp.ParserElement = pp.Regex(uuid_regexp.pattern)
+
+strict_relpath_regexp: re.Pattern[str] = re.compile(
+    rf"(?!.*(^|/)\.+($|/))(?:{strict_chars_regexp.pattern}/)*(?:{strict_chars_regexp.pattern})?")
+strict_abspath_regexp: re.Pattern[str] = re.compile(
+    rf"(?!.*(^|/)\.+($|/))/(?:{strict_chars_regexp.pattern}/)*(?:{strict_chars_regexp.pattern})?")
+
+strict_path_chars_element = strict_chars_element.copy()
+strict_path_chars_element.add_condition(token_reparse(period_token[1, ...], negate=True),
+                                        message="cannot be pure dots")
+
+strict_relpath_element: pp.ParserElement = pp.Combine(
+    (strict_path_chars_element + slash_token)[...] + strict_path_chars_element[0, 1])
+strict_abspath_element: pp.ParserElement = pp.Combine(
+    slash_token + (strict_path_chars_element + slash_token)[...] + strict_path_chars_element[0, 1])
+
+tag_regexp: re.Pattern[str] = re.compile(rf"{snake_case_regexp.pattern}(?:::{snake_case_regexp.pattern})*")
+tag_element: pp.ParserElement = pp.Combine(snake_case_element + (colon_token + colon_token + snake_case_element)[...])
+
+topic_regexp: re.Pattern[str] = re.compile(rf"(?:/{snake_case_regexp.pattern})+")
+topic_element: pp.ParserElement = pp.Combine((slash_token + snake_case_element)[1, ...])
+
+vin_code_chars: str = "0123456789ABCDEFGHJKLMNPRSTUVWXYZ"
+
+vin_code_regexp: re.Pattern[str] = re.compile(rf"[{vin_code_chars}]{{17}}")
+vin_code_element: pp.ParserElement = pp.Regex(vin_code_regexp.pattern)
+
+hex_string_pattern = make_string_pattern(hex_digits_regexp)
+hex_string_parser = make_string_parser(hex_digits_element)
+
+snake_case_pattern = make_string_pattern(snake_case_regexp)
+snake_case_parser = make_string_parser(snake_case_element)
+kebab_case_pattern = make_string_pattern(kebab_case_regexp)
+kebab_case_parser = make_string_parser(kebab_case_element)
+dot_case_pattern = make_string_pattern(dot_case_regexp)
+dot_case_parser = make_string_parser(dot_case_element)
+
+uuid_pattern = make_string_pattern(uuid_regexp)
+uuid_parser = make_string_parser(uuid_element)
+
+strict_relpath_pattern = make_string_pattern(strict_relpath_regexp)
+strict_relpath_parser = make_string_parser(strict_relpath_element)
+strict_abspath_pattern = make_string_pattern(strict_abspath_regexp)
+strict_abspath_parser = make_string_parser(strict_abspath_element)
+
+tag_pattern = make_string_pattern(tag_regexp)
+tag_parser = make_string_parser(tag_element)
+topic_pattern = make_string_pattern(topic_regexp)
+topic_parser = make_string_parser(topic_element)
+vin_code_pattern = make_string_pattern(vin_code_regexp)
+vin_code_parser = make_string_parser(vin_code_element)
+
+
+@dataclasses.dataclass(frozen=True, eq=True)
+class UserName(object):
+    first_name: str
+    last_name: str
+    sn: int = 0
+
+    def __str__(self) -> str:
+        if self.sn == 0:
+            return f"{self.first_name}.{self.last_name}"
+        return f"{self.first_name}{self.sn}.{self.last_name}"
+
+
+@dataclasses.dataclass(frozen=True, eq=True)
+class VehicleName(object):
+    brand: str
+    alias: str
+    code: str | None = None
+    vin: str | None = None
+
+    def __str__(self) -> str:
+        if self.code and self.vin:
+            return f"{self.brand}_{self.alias}_{self.code}_V{self.vin}"
+        if self.code:
+            return f"{self.brand}_{self.alias}_{self.code}"
+        if self.vin:
+            return f"{self.brand}_{self.alias}_V{self.vin}"
+        return f"{self.brand}_{self.alias}"
+
+
+@dataclasses.dataclass(frozen=True, eq=True)
+class BagName(object):
+    vehicle_name: VehicleName
+    record_dt: datetime.datetime
+    record_sn: int
+
+    def __str__(self) -> str:
+        return f"{dt_format(self.record_dt, basic_format())}-{self.vehicle_name}-{self.record_sn}.bag"
+
+
+@singleton
+def get_user_name_parser() -> pp.ParserElement:
+    element = pp.Combine(lowers_element("first_name") +
+                         positive_number_element("sn")[0, 1] +
+                         period_token +
+                         lowers_element("last_name"))
+    return make_string_parser(element)
+
+
+@singleton
+def get_vehicle_name_parser() -> pp.ParserElement:
+    element = pp.Combine(lower_identifier_element("brand") +
+                         (underscore_token +
+                          pp.Combine(lower_identifier_element +
+                                     (underscore_token + lower_identifier_element)[...])("alias")) +
+                         (underscore_token + digits_element("code"))[0, 1] +
+                         (underscore_token + pp.Char("V") + vin_code_element("vin"))[0, 1])
+    return make_string_parser(element)
+
+
+@singleton
+def get_bag_name_parser() -> pp.ParserElement:
+    element = pp.Combine(basic_datetime_element("record_dt") +
+                         (hyphen_token +
+                          pp.Group(lower_identifier_element("brand") +
+                                   (underscore_token +
+                                    pp.Combine(lower_identifier_element +
+                                               (underscore_token + lower_identifier_element)[...])("alias")) +
+                                   (underscore_token + digits_element("code"))[0, 1] +
+                                   (underscore_token + pp.Char("V") + vin_code_element("vin"))[0, 1])("vehicle_name")) +
+                         (hyphen_token + number_element("record_sn")) +
+                         (period_token + pp.Literal("bag"))[0, 1])
+    return make_string_parser(element)
+
+
+def parse_user_name(s: str) -> UserName | None:
+    user_name_match = get_user_name_parser().parse_string(s, parse_all=True)
+
+    return UserName(
+        user_name_match.get("first_name"),
+        user_name_match.get("last_name"),
+        int(user_name_match.get("sn", 0)),
+    )
+
+
+def parse_vehicle_name(s: str) -> VehicleName | None:
+    vehicle_name_match = get_vehicle_name_parser().parse_string(s, parse_all=True)
+
+    return VehicleName(
+        vehicle_name_match.get("brand"),
+        vehicle_name_match.get("alias"),
+        vehicle_name_match.get("code"),
+        vehicle_name_match.get("vin"),
+    )
+
+
+def parse_bag_name(s: str) -> BagName | None:
+    bag_name_match = get_bag_name_parser().parse_string(s, parse_all=True)
+
+    return BagName(
+        VehicleName(
+            bag_name_match.get("vehicle_name").get("brand"),
+            bag_name_match.get("vehicle_name").get("alias"),
+            bag_name_match.get("vehicle_name").get("code"),
+            bag_name_match.get("vehicle_name").get("vin"),
+        ),
+        dt_parse(bag_name_match.get("record_dt"), basic_format()),
+        int(bag_name_match.get("record_sn")),
+    )

plexus_python_common-1.0.7.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: plexus-python-common
+Version: 1.0.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Requires-Dist: cloudpathlib>=0.21
+Requires-Dist: lxml>=4.9
+Requires-Dist: numpy>=1.26
+Requires-Dist: pydantic>=2.8
+Requires-Dist: pygeodesy>=24.10
+Requires-Dist: pyparsing>=3.2
+Requires-Dist: pyproj>=3.6
+Requires-Dist: pyquaternion>=0.9
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: sqlmodel
+Requires-Dist: rich>=13.9
+Requires-Dist: ujson>=5.9
+Requires-Dist: iker-python-common[all]>=1.0
+Provides-Extra: all
+Requires-Dist: plexus-python-common; extra == "all"
+Provides-Extra: test
+Requires-Dist: ddt>=1.7; extra == "test"
+Requires-Dist: pytest-cov>=5.0; extra == "test"
+Requires-Dist: pytest-order>=1.3; extra == "test"
+Requires-Dist: pytest-postgresql>=6.1; extra == "test"
+Requires-Dist: pytest>=8.3; extra == "test"

plexus_python_common-1.0.7.dist-info/RECORD

@@ -0,0 +1,21 @@
+plexus/common/__init__.py,sha256=uWSQ4w3n7-zO3xJA1MTde4zbyZ73W8eVQ2EcoDzHwqc,177
+plexus/common/config.py,sha256=kbJAkhAF1E8kGjp-0hrDlWav5XjpsDTDPjZS0L0R5MQ,2960
+plexus/common/pose.py,sha256=abF-kOZIApFoTaqBGWDAQne75y3dv7RpFmHiNO-drIM,2850
+plexus/common/proj.py,sha256=qs3UFLmZaDyxentQgK7suSqZ8_KXYSvvLQhuKzDBJlQ,8742
+plexus/common/carto/OSMFile.py,sha256=yKG0ImkUNOrOs6oiEANDKZ6KaQCTEaPSolYMVLACVB0,8136
+plexus/common/carto/OSMNode.py,sha256=XJkp-tD945tFz3MWO5v3IdGfsjZy3YZE_yaBNc4dTdM,593
+plexus/common/carto/OSMTags.py,sha256=wGtdfl1gzuXMk75xU2cyeF6hwFdKADxq77fah7vrFwg,3450
+plexus/common/carto/OSMWay.py,sha256=zqSUzn_evoYwG51ZbSOCBbzHKQ2fFIDcaToYE9SVKxE,562
+plexus/common/carto/__init__.py,sha256=rmUEoSB4Rq3xmFGD16Y7zkjWpzbkxJgZEXt2Vnqxhws,264
+plexus/common/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plexus/common/utils/bagutils.py,sha256=SzlSaAVUJeIXvQH8PFPV7CJHxspBfWafPQn8_TXRr9o,7326
+plexus/common/utils/datautils.py,sha256=Hb7wYvMS1XUBh3RVxuGypuZ-JYm37_cWfRtD1Whv4fQ,7972
+plexus/common/utils/jsonutils.py,sha256=bhaB6mT-otPhBptoxAU_IG7fBYvGVSTYLhC_r_H5JNI,3243
+plexus/common/utils/ormutils.py,sha256=lhZvzZsr5Ann0_Vc1XNrDKo_C8JaesN8L5eaww_zFeo,12779
+plexus/common/utils/s3utils.py,sha256=DCMv_GbMg8Z_xhi32zLAlr5ja08m4JJcKnXY9-ufZTA,4271
+plexus/common/utils/shutils.py,sha256=hGJqSLj08tuOeZ7WeC5d4BtjnPI732BuntVQBQsqOaI,9581
+plexus/common/utils/strutils.py,sha256=unZgCiiE3WOBrZ6O4G_YEuSCk9peJLsfd6vrGRiDRIo,11445
+plexus_python_common-1.0.7.dist-info/METADATA,sha256=WBIINeZpFqrnBZ6MNrk5j340U7QUXKvQ7znWTL6rpvY,1014
+plexus_python_common-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+plexus_python_common-1.0.7.dist-info/top_level.txt,sha256=ug_g7CVwaMQuas5UzAXbHUrQvKGCn8ezc6ZNvvRlJOE,7
+plexus_python_common-1.0.7.dist-info/RECORD,,