plexus-python-common 1.0.18__tar.gz → 1.0.19__tar.gz

{plexus_python_common-1.0.18 → plexus_python_common-1.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.18
+Version: 1.0.19
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_common-1.0.18 → plexus_python_common-1.0.19}/src/plexus/common/utils/ormutils.py

@@ -496,7 +496,10 @@ def make_snapshot_model_trigger(engine: sa.Engine, model: type[SQLModel]):
             conn.execute(sa.text(create_snapshot_auto_update_trigger_sql))
 
 
-def db_make_order_by_clause[SerialModelT: SerialModelMixin](model: type[SerialModelT], order_by: list[str] = None):
+def db_make_order_by_clause[SerialModelT: SerialModelMixin](
+    model: type[SerialModelT],
+    order_by: list[str] | None = None,
+):
     order_criteria = []
     if order_by:
         for field in order_by:
@@ -548,11 +551,16 @@ def db_read_serial_model[SerialModelT: SerialModelMixin](
 def db_read_serial_models[SerialModelT: SerialModelMixin](
     db: sa_orm.Session,
     model: type[SerialModelT],
-    skip: int,
-    limit: int,
-    order_by: list[str] = None,
+    skip: int | None = None,
+    limit: int | None = None,
+    order_by: list[str] | None = None,
 ) -> list[SerialModelT]:
-    return db.query(model).order_by(*db_make_order_by_clause(model, order_by)).offset(skip).limit(limit).all()
+    query = db.query(model).order_by(*db_make_order_by_clause(model, order_by))
+    if skip is not None:
+        query = query.offset(skip)
+    if limit is not None:
+        query = query.limit(limit)
+    return query.all()
 
 
 def db_update_serial_model[SerialModelT: SerialModelMixin](
@@ -736,9 +744,9 @@ def db_read_expired_snapshot_models_of_record[SnapshotModelT: SnapshotModelMixin
 def db_read_latest_snapshot_models[SnapshotModelT: SnapshotModelMixin](
     db: sa_orm.Session,
     model: type[SnapshotModelT],
-    skip: int,
-    limit: int,
-    order_by: list[str] = None,
+    skip: int | None = None,
+    limit: int | None = None,
+    order_by: list[str] | None = None,
 ) -> list[SnapshotModelT]:
     subquery = (
         db
@@ -748,34 +756,33 @@ def db_read_latest_snapshot_models[SnapshotModelT: SnapshotModelMixin](
         .subquery()
     )
 
-    return (
+    query = (
         db
         .query(model)
         .join(subquery,
               sa.and_(model.record_sid == subquery.c.record_sid, model.created_at == subquery.c.max_created_at))
         .order_by(*db_make_order_by_clause(model, order_by))
-        .offset(skip)
-        .limit(limit)
-        .all()
     )
+    if skip is not None:
+        query = query.offset(skip)
+    if limit is not None:
+        query = query.limit(limit)
+    return query.all()
 
 
 def db_read_active_snapshot_models[SnapshotModelT: SnapshotModelMixin](
     db: sa_orm.Session,
     model: type[SnapshotModelT],
-    skip: int,
-    limit: int,
-    order_by: list[str] = None,
+    skip: int | None = None,
+    limit: int | None = None,
+    order_by: list[str] | None = None,
 ) -> list[SnapshotModelT]:
-    return (
-        db
-        .query(model)
-        .where(model.expired_at.is_(None))
-        .order_by(*db_make_order_by_clause(model, order_by))
-        .offset(skip)
-        .limit(limit)
-        .all()
-    )
+    query = db.query(model).where(model.expired_at.is_(None)).order_by(*db_make_order_by_clause(model, order_by))
+    if skip is not None:
+        query = query.offset(skip)
+    if limit is not None:
+        query = query.limit(limit)
+    return query.all()
 
 
 def db_update_snapshot_model[SnapshotModelT: SnapshotModelMixin](

{plexus_python_common-1.0.18 → plexus_python_common-1.0.19}/src/plexus/common/utils/strutils.py

@@ -33,10 +33,14 @@ __all__ = [
     "vin_code_chars",
     "vin_code_pattern",
     "vin_code_parser",
+    "to_colon_tag",
+    "to_slash_tag",
     "UserName",
+    "UserEmail",
     "VehicleName",
     "BagName",
     "parse_user_name",
+    "parse_user_email",
     "parse_vehicle_name",
     "parse_bag_name",
 ]
@@ -193,6 +197,14 @@ vin_code_pattern = make_string_pattern(vin_code_regexp)
 vin_code_parser = make_string_parser(vin_code_element)
 
 
+def to_colon_tag(tag: str) -> str:
+    return tag.replace("/", ":")
+
+
+def to_slash_tag(tag: str) -> str:
+    return tag.replace(":", "/")
+
+
 @dataclasses.dataclass(frozen=True, eq=True)
 class UserName(object):
     first_name: str
@@ -205,6 +217,15 @@ class UserName(object):
         return f"{self.first_name}{self.sn}.{self.last_name}"
 
 
+@dataclasses.dataclass(frozen=True, eq=True)
+class UserEmail(object):
+    user_name: UserName
+    domain: str
+
+    def __str__(self) -> str:
+        return f"{str(self.user_name)}@{self.domain}"
+
+
 @dataclasses.dataclass(frozen=True, eq=True)
 class VehicleName(object):
     brand: str
@@ -232,39 +253,58 @@ class BagName(object):
         return f"{dt_format(self.record_dt, basic_format())}-{self.vehicle_name}-{self.record_sn}.bag"
 
 
+@singleton
+def get_user_name_element() -> pp.ParserElement:
+    return pp.Combine(lowers_element("first_name") +
+                      positive_number_element("sn")[0, 1] +
+                      period_token +
+                      lowers_element("last_name"))
+
+
 @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)
+    return make_string_parser(get_user_name_element())
+
+
+@singleton
+def get_user_email_element() -> pp.ParserElement:
+    return pp.Combine(get_user_name_element()("user_name") +
+                      pp.Char("@") +
+                      pp.Combine((kebab_case_element + period_token)[1, ...] + lowers_element)("domain"))
+
+
+@singleton
+def get_user_email_parser() -> pp.ParserElement:
+    return make_string_parser(get_user_email_element())
+
+
+@singleton
+def get_vehicle_name_element() -> pp.ParserElement:
+    return 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])
 
 
 @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)
+    return make_string_parser(get_vehicle_name_element())
+
+
+@singleton
+def get_bag_name_element() -> pp.ParserElement:
+    return pp.Combine(basic_datetime_element("record_dt") +
+                      (hyphen_token +
+                       get_vehicle_name_element()("vehicle_name")) +
+                      (hyphen_token + number_element("record_sn")) +
+                      (period_token + pp.Literal("bag"))[0, 1])
 
 
 @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)
+    return make_string_parser(get_bag_name_element())
 
 
 def parse_user_name(s: str) -> UserName | None:
@@ -277,6 +317,19 @@ def parse_user_name(s: str) -> UserName | None:
     )
 
 
+def parse_user_email(s: str) -> UserEmail | None:
+    user_email_match = get_user_email_parser().parse_string(s, parse_all=True)
+
+    return UserEmail(
+        UserName(
+            user_email_match.get("user_name").get("first_name"),
+            user_email_match.get("user_name").get("last_name"),
+            int(user_email_match.get("user_name").get("sn", 0)),
+        ),
+        user_email_match.get("domain"),
+    )
+
+
 def parse_vehicle_name(s: str) -> VehicleName | None:
     vehicle_name_match = get_vehicle_name_parser().parse_string(s, parse_all=True)
 

{plexus_python_common-1.0.18 → plexus_python_common-1.0.19}/src/plexus_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.18
+Version: 1.0.19
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_common-1.0.18 → plexus_python_common-1.0.19}/test/plexus_tests/common/utils/strutils_test.py

@@ -4,12 +4,12 @@ import ddt
 import pyparsing as pp
 from iker.common.utils.dtutils import dt_parse_iso
 
-from plexus.common.utils.strutils import BagName, UserName, VehicleName
+from plexus.common.utils.strutils import BagName, UserEmail, UserName, VehicleName
 from plexus.common.utils.strutils import colon_tag_parser, colon_tag_pattern, slash_tag_parser, slash_tag_pattern
 from plexus.common.utils.strutils import dot_case_parser, dot_case_pattern
 from plexus.common.utils.strutils import hex_string_parser, hex_string_pattern
 from plexus.common.utils.strutils import kebab_case_parser, kebab_case_pattern
-from plexus.common.utils.strutils import parse_bag_name, parse_user_name, parse_vehicle_name
+from plexus.common.utils.strutils import parse_bag_name, parse_user_email, parse_user_name, parse_vehicle_name
 from plexus.common.utils.strutils import semver_parser, semver_pattern
 from plexus.common.utils.strutils import snake_case_parser, snake_case_pattern
 from plexus.common.utils.strutils import strict_abspath_parser, strict_abspath_pattern
@@ -568,6 +568,51 @@ class StrUtilsTest(unittest.TestCase):
         with self.assertRaises(pp.ParseException):
             parse_user_name(data)
 
+    data_parse_user_email = [
+        ("dummy.person@some.company", UserEmail(UserName("dummy", "person", 0), "some.company")),
+        ("dummy1.person@another.company", UserEmail(UserName("dummy", "person", 1), "another.company")),
+        ("dummy1.person@yet-another.company", UserEmail(UserName("dummy", "person", 1), "yet-another.company")),
+        ("dummy1.person@yet-yet.another.company", UserEmail(UserName("dummy", "person", 1), "yet-yet.another.company")),
+        ("dummy999999.person@good.company", UserEmail(UserName("dummy", "person", 999999), "good.company")),
+        ("dummy.person@better.or.even-better.company",
+         UserEmail(UserName("dummy", "person", 0), "better.or.even-better.company")),
+    ]
+
+    @ddt.idata(data_parse_user_email)
+    @ddt.unpack
+    def test_parse_user_email(self, data, expect):
+        self.assertEqual(parse_user_email(data), expect)
+        self.assertEqual(data, str(expect))
+
+    data_parse_user_email__bad_cases = [
+        ("dummy",),
+        ("0.dummy",),
+        ("dummy.0",),
+        ("Dummy.Dummy",),
+        ("dummy-dummy.dummy",),
+        ("0dummy.dummy",),
+        ("0dummy0.dummy",),
+        ("dummy01.dummy",),
+        ("dummy@some.company",),
+        ("0.dummy@some.company",),
+        ("dummy.0@some.company",),
+        ("Dummy.Dummy@some.company",),
+        ("dummy-dummy.dummy@some.company",),
+        ("0dummy.dummy@some.company",),
+        ("0dummy0.dummy@some.company",),
+        ("dummy01.dummy@some.company",),
+        ("dummy.person@BAD.COMPANY",),
+        ("dummy1.person@worse.company.",),
+        ("dummy1.person@even.worse-company",),
+        ("dummy1.person#worst.company",),
+    ]
+
+    @ddt.idata(data_parse_user_email__bad_cases)
+    @ddt.unpack
+    def test_parse_user_email__bad_cases(self, data):
+        with self.assertRaises(pp.ParseException):
+            parse_user_email(data)
+
     data_parse_vehicle_name = [
         ("brand_alias",
          VehicleName("brand", "alias", None, None)),