plexus-python-common 1.0.32__tar.gz → 1.0.33__tar.gz

{plexus_python_common-1.0.32 → plexus_python_common-1.0.33}/PKG-INFO

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

{plexus_python_common-1.0.32 → plexus_python_common-1.0.33}/src/plexus/common/utils/s3utils.py

@@ -37,11 +37,14 @@ __all__ = [
     "s3_pull_text",
     "s3_push_text",
     "S3TransferCallbackClient",
+    "ArchiveMemberChunk",
     "s3_make_progress_callback",
     "s3_make_progressed_client",
     "s3_archive_member_tree",
     "s3_archive_listfile",
     "s3_archive_open_member",
+    "s3_archive_use_ranged_requests",
+    "s3_archive_use_chunked_reads",
     "s3_archive_open_members",
 ]
 
@@ -658,17 +661,86 @@ def s3_archive_open_member(
         yield s3_fh
 
 
-ZIPFILE_HEADER_MIN_SIZE = 30
-ZIPFILE_HEADER_FN_LEN_OFFSET = 26
-ZIPFILE_HEADER_EX_LEN_OFFSET = 28
+ZIP_CENTRAL_DIR_ESTIMATED_SIZE = 64 * 1024
+ZIP_INFO_HDR_MIN_SIZE = 30
+ZIP_INFO_HDR_ESTIMATED_SIZE = 128
+ZIP_INFO_HDR_FN_LEN_OFFSET = 26
+ZIP_INFO_HDR_EX_LEN_OFFSET = 28
 
 
-def zipfile_hdr_fn_len_slice(offset: int) -> slice:
-    return slice(offset + ZIPFILE_HEADER_FN_LEN_OFFSET, offset + ZIPFILE_HEADER_FN_LEN_OFFSET + 2)
+@dataclasses.dataclass(frozen=True)
+class ArchiveMemberChunk(object):
+    name: str
+    header_offset: int
+    compress_size: int
+    compress_type: int
+    header_overhead: int = ZIP_INFO_HDR_ESTIMATED_SIZE
 
+    @property
+    def begin(self) -> int:
+        return self.header_offset
 
-def zipfile_hdr_ex_len_slice(offset: int) -> slice:
-    return slice(offset + ZIPFILE_HEADER_EX_LEN_OFFSET, offset + ZIPFILE_HEADER_EX_LEN_OFFSET + 2)
+    @property
+    def end(self) -> int:
+        return self.header_offset + self.header_overhead + self.compress_size
+
+
+def s3_archive_use_ranged_requests(
+    threshold: float = 0.5,
+    central_directory_overhead: int = 64 * ZIP_CENTRAL_DIR_ESTIMATED_SIZE,
+    zip_info_header_overhead: int = ZIP_INFO_HDR_ESTIMATED_SIZE,
+) -> Callable[[int, list[zipfile.ZipInfo]], bool]:
+    """
+    Decide whether to use ranged requests for accessing members of a ZIP archive in S3
+    based on estimated transfer size ratio.
+
+    :param threshold: If (estimated ranged transfer bytes / archive bytes) <= threshold, use ranged per-member access;
+                      otherwise download the whole archive.
+    :param central_directory_overhead: Estimated overhead size for the central directory in bytes.
+    :param zip_info_header_overhead: Estimated overhead size for each member's ``ZipInfo`` header in bytes.
+    :return: A callable that takes (``archive_size``, ``member_zip_infos``) and returns a boolean
+             indicating whether to use ranged requests.
+    """
+
+    if zip_info_header_overhead < ZIP_INFO_HDR_MIN_SIZE:
+        raise ValueError(f"zip_info_header_overhead must be at least {ZIP_INFO_HDR_MIN_SIZE} bytes")
+
+    def use_ranged_requests(
+        archive_size: int,
+        member_zip_infos: list[zipfile.ZipInfo],
+    ) -> bool:
+        estimated_ranged_total_size = central_directory_overhead + sum(info.compress_size + zip_info_header_overhead
+                                                                       for info in member_zip_infos)
+
+        # Avoid division by zero; prefer ranged if archive size is zero (degenerate case)
+        return (estimated_ranged_total_size / archive_size) <= threshold if archive_size > 0 else True
+
+    return use_ranged_requests
+
+
+def s3_archive_use_chunked_reads(
+    zip_info_header_overhead: int = ZIP_INFO_HDR_ESTIMATED_SIZE,
+) -> Callable[[zipfile.ZipInfo], ArchiveMemberChunk]:
+    """
+    Map each ``ZipInfo`` to an ``ArchiveMemberChunk`` for grouping adjacent members into single ranged reads.
+
+    :param zip_info_header_overhead: Estimated overhead size for each member's ``ZipInfo`` header in bytes.
+    :return: A callable that takes a ``ZipInfo`` and returns an ``ArchiveMemberChunk``.
+    """
+
+    if zip_info_header_overhead < ZIP_INFO_HDR_MIN_SIZE:
+        raise ValueError(f"zip_info_header_overhead must be at least {ZIP_INFO_HDR_MIN_SIZE} bytes")
+
+    def use_chunked_reads(
+        zip_info: zipfile.ZipInfo,
+    ) -> ArchiveMemberChunk:
+        return ArchiveMemberChunk(zip_info.filename,
+                                  zip_info.header_offset,
+                                  zip_info.compress_size,
+                                  zip_info.compress_type,
+                                  header_overhead=zip_info_header_overhead)
+
+    return use_chunked_reads
 
 
 def s3_archive_open_members(
@@ -678,10 +750,8 @@ def s3_archive_open_members(
     members: list[str] | None = None,
     mode: Literal["r", "rb"] = "r",
     *,
-    threshold: float = 0.5,
-    central_directory_overhead: int = 64 * 1024,
-    member_header_overhead: int = 128,
-    use_chunked_reads: bool = False,
+    use_ranged_requests: bool | Callable[[int, list[zipfile.ZipInfo]], bool] = True,
+    use_chunked_reads: bool | Callable[[zipfile.ZipInfo], ArchiveMemberChunk] = False,
 ) -> Generator[tuple[str, Callable[[], typing.IO]], None, None]:
     """
     Choose the best transfer strategy (ranged requests per-member vs full archive transfer)
@@ -712,44 +782,30 @@ def s3_archive_open_members(
     :param key: Object key of the ZIP archive.
     :param members: List of member names to stream.
     :param mode: File mode for opening members ("r" for text, "rb" for binary).
-    :param threshold: If (estimated ranged transfer bytes / archive bytes) <= threshold,
-                      use ranged per-member access; otherwise download the whole archive.
-    :param central_directory_overhead: Passed to s3_estimate_archive_ranged_requests.
-    :param member_header_overhead: Passed to s3_estimate_archive_ranged_requests.
-    :param use_chunked_reads: If ``True`` and ranged access is chosen, group adjacent members into single ranged reads.
+    :param use_ranged_requests: If ``True``, always use ranged requests to access the archive; if callable, use it as
+                                custom logic to decide based on the archive size and member infos; if ``False``, always
+                                download the whole archive.
+    :param use_chunked_reads: If ``True``, group adjacent members into single ranged reads using default ``ZipInfo``
+                              to ``ArchiveMemberChunk`` mapping; if callable, use it as custom mapping from
+                              ``ZipInfo`` to ``ArchiveMemberChunk`` for grouping adjacent members; if ``False``,
+                              read each member with individual ranged requests. If ``use_ranged_requests`` is ``False``,
+                              this parameter is ignored.
 
     :return: An iterable of callables that return file-like objects for each requested member.
     """
     if mode not in ("r", "rb"):
         raise ValueError("mode must be either 'r' or 'rb'")
-    if member_header_overhead < ZIPFILE_HEADER_MIN_SIZE:
-        raise ValueError(f"member_header_overhead must be at least {ZIPFILE_HEADER_MIN_SIZE} bytes")
 
     s3_options = s3_options_from_s3_client(client)
 
     archive_size, member_zip_infos, missed_members = s3_archive_listfile(client, bucket, key, members)
+    if missed_members:
+        raise FileNotFoundError(f"Archive members not found: {', '.join(missed_members)}")
 
-    if len(missed_members) > 0:
-        raise FileNotFoundError(f"members not found in archive '{missed_members}'")
-
-    estimated_ranged_total_size = central_directory_overhead + sum(info.compress_size + member_header_overhead
-                                                                   for info in member_zip_infos)
-
-    # Avoid division by zero; prefer ranged if archive size is zero (degenerate case)
-    use_ranged = (estimated_ranged_total_size / archive_size) <= threshold if archive_size > 0 else True
+    if callable(use_ranged_requests):
+        use_ranged_requests = use_ranged_requests(archive_size, member_zip_infos)
 
-    @dataclasses.dataclass(frozen=True)
-    class MemberChunk(object):
-        name: str
-        header_offset: int
-        compress_size: int
-        compress_type: int
-
-        @property
-        def end(self) -> int:
-            return self.header_offset + self.compress_size + member_header_overhead
-
-    if use_ranged and not use_chunked_reads:
+    if use_ranged_requests and not use_chunked_reads:
         for info in member_zip_infos:
             opener = functools.partial(s3_archive_open_member, client, bucket, key, info.filename, mode)
             yield info.filename, opener
@@ -757,17 +813,23 @@ def s3_archive_open_members(
 
     archive_url = f"s3://{bucket}/{key}"
 
-    if use_ranged and use_chunked_reads:
+    if use_ranged_requests and use_chunked_reads:
+
+        fn_len_slice = lambda index: slice(index + ZIP_INFO_HDR_FN_LEN_OFFSET, index + ZIP_INFO_HDR_FN_LEN_OFFSET + 2)
+        ex_len_slice = lambda index: slice(index + ZIP_INFO_HDR_EX_LEN_OFFSET, index + ZIP_INFO_HDR_EX_LEN_OFFSET + 2)
+
         # Open archive once to read central directory and gather ZipInfo for requested members.
         # We will group adjacent members (by local header offsets) and issue one ranged read per group,
         # then extract each member from the group's bytes to avoid many small ranged requests.
         with fsspec.open(archive_url, "rb", s3=s3_options) as s3_fh, zipfile.ZipFile(s3_fh) as archive:
+            if callable(use_chunked_reads):
+                chunks = [use_chunked_reads(info) for info in member_zip_infos]
+            else:
+                chunks = [ArchiveMemberChunk(info.filename, info.header_offset, info.compress_size, info.compress_type)
+                          for info in member_zip_infos]
 
-            chunks = [MemberChunk(info.filename, info.header_offset, info.compress_size, info.compress_type)
-                      for info in member_zip_infos]
-
-            chunks_groups = chunk_between(sorted(chunks, key=lambda x: x.header_offset),
-                                          chunk_func=lambda x, y: y.header_offset > x.end + member_header_overhead)
+            chunks_groups = chunk_between(sorted(chunks, key=lambda x: x.begin),
+                                          chunk_func=lambda x, y: y.begin > x.end)
 
             # For each group, create openers for members inside the group.
             for group in chunks_groups:
@@ -778,18 +840,18 @@ def s3_archive_open_members(
                 s3_fh.seek(group_offset)
                 group_bytes = s3_fh.read(group_size)
 
-                def make_opener(chunk: MemberChunk) -> Callable[[], typing.IO]:
+                def make_opener(chunk: ArchiveMemberChunk) -> Callable[[], typing.IO]:
 
                     def opener() -> typing.IO:
                         index = chunk.header_offset - group_offset
 
-                        if index + ZIPFILE_HEADER_MIN_SIZE > len(group_bytes):
+                        if index + ZIP_INFO_HDR_MIN_SIZE > len(group_bytes):
                             raise IOError("unexpected short read of member header")
 
-                        fn_len = int.from_bytes(group_bytes[zipfile_hdr_fn_len_slice(index)], "little")
-                        ex_len = int.from_bytes(group_bytes[zipfile_hdr_ex_len_slice(index)], "little")
+                        fn_len = int.from_bytes(group_bytes[fn_len_slice(index)], "little")
+                        ex_len = int.from_bytes(group_bytes[ex_len_slice(index)], "little")
 
-                        raw_data_begin = index + ZIPFILE_HEADER_MIN_SIZE + fn_len + ex_len
+                        raw_data_begin = index + ZIP_INFO_HDR_MIN_SIZE + fn_len + ex_len
                         raw_data_end = raw_data_begin + chunk.compress_size
 
                         if raw_data_end > len(group_bytes):

{plexus_python_common-1.0.32 → plexus_python_common-1.0.33}/src/plexus/common/utils/strutils.py

@@ -22,6 +22,10 @@ __all__ = [
     "strict_relpath_parser",
     "strict_abspath_pattern",
     "strict_abspath_parser",
+    "strict_archive_relpath_pattern",
+    "strict_archive_relpath_parser",
+    "strict_archive_abspath_pattern",
+    "strict_archive_abspath_parser",
     "email_address_pattern",
     "email_address_parser",
     "semver_pattern",
@@ -82,6 +86,7 @@ period_token: pp.ParserElement = pp.Char(".")
 colon_token: pp.ParserElement = pp.Char(":")
 slash_token: pp.ParserElement = pp.Char("/")
 plus_token: pp.ParserElement = pp.Char("+")
+sharp_token: pp.ParserElement = pp.Char("#")
 
 lower_regexp: re.Pattern[str] = re.compile(r"[a-z]")
 upper_regexp: re.Pattern[str] = re.compile(r"[A-Z]")
@@ -155,6 +160,10 @@ 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_archive_relpath_regexp: re.Pattern[str] = re.compile(
+    rf"(?!.*(^|/)\.+($|/))(?:{strict_chars_regexp.pattern}/)*({strict_chars_regexp.pattern})(?:#({strict_relpath_regexp.pattern}))?")
+strict_archive_abspath_regexp: re.Pattern[str] = re.compile(
+    rf"(?!.*(^|/)\.+($|/))/(?:{strict_chars_regexp.pattern}/)*({strict_chars_regexp.pattern})(?:#({strict_relpath_regexp.pattern}))?")
 
 strict_path_chars_element = strict_chars_element.copy()
 strict_path_chars_element.add_condition(token_reparse(period_token[1, ...], negate=True),
@@ -164,6 +173,12 @@ 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])
+strict_archive_relpath_element: pp.ParserElement = pp.Combine(
+    (strict_path_chars_element + slash_token)[...] + strict_path_chars_element +
+    (sharp_token + strict_relpath_element)[0, 1])
+strict_archive_abspath_element: pp.ParserElement = pp.Combine(
+    slash_token + (strict_path_chars_element + slash_token)[...] + strict_path_chars_element +
+    (sharp_token + strict_relpath_element)[0, 1])
 
 email_address_regexp: re.Pattern[str] = re.compile(
     rf"(({lower_digit_regexp.pattern}|[_-])+)(?:\.({lower_digit_regexp.pattern}|[_-])+)*@(?:{kebab_case_regexp.pattern}\.)+({lower_digit_regexp.pattern}{{2,63}})")
@@ -206,6 +221,10 @@ 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)
+strict_archive_relpath_pattern = make_string_pattern(strict_archive_relpath_regexp)
+strict_archive_relpath_parser = make_string_parser(strict_archive_relpath_element)
+strict_archive_abspath_pattern = make_string_pattern(strict_archive_abspath_regexp)
+strict_archive_abspath_parser = make_string_parser(strict_archive_abspath_element)
 
 email_address_pattern = make_string_pattern(email_address_regexp)
 email_address_parser = make_string_parser(email_address_element)

{plexus_python_common-1.0.32 → plexus_python_common-1.0.33}/src/plexus_python_common.egg-info/PKG-INFO

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

{plexus_python_common-1.0.32 → plexus_python_common-1.0.33}/test/plexus_tests/common/utils/s3utils_test.py

@@ -575,12 +575,12 @@ class S3UtilsTest(unittest.TestCase):
             local_root = os.path.join(resources_directory, "unittest", "s3utils")
             local_members = [os.path.relpath(file_path, local_root) for file_path in listfile(local_root)]
 
-            for archive_key, members, mode, threshold, use_chunked_reads in itertools.product(
+            for archive_key, members, mode, use_ranged_requests, use_chunked_reads in itertools.product(
                 ["s3utils_archive/archive.uncompressed.zip", "s3utils_archive/archive.compressed.zip"],
                 [local_members, None],
                 ["r", "rb"],
-                [1.0, 0.0],
-                [False, True],
+                [False, True, s3_archive_use_ranged_requests()],
+                [False, True, s3_archive_use_chunked_reads()],
             ):
                 for member, opener in s3_archive_open_members(
                     client,
@@ -588,8 +588,7 @@ class S3UtilsTest(unittest.TestCase):
                     archive_key,
                     members,
                     mode,
-                    threshold=threshold,
-                    central_directory_overhead=0,
+                    use_ranged_requests=use_ranged_requests,
                     use_chunked_reads=use_chunked_reads,
                 ):
                     with open(os.path.join(local_root, member), mode) as local_fh, opener() as s3_fh:

{plexus_python_common-1.0.32 → plexus_python_common-1.0.33}/test/plexus_tests/common/utils/strutils_test.py

@@ -13,6 +13,8 @@ from plexus.common.utils.strutils import kebab_case_parser, kebab_case_pattern
 from plexus.common.utils.strutils import parse_bag_name, parse_user_email, parse_user_name, parse_vehicle_name
 from plexus.common.utils.strutils import snake_case_parser, snake_case_pattern
 from plexus.common.utils.strutils import strict_abspath_parser, strict_abspath_pattern
+from plexus.common.utils.strutils import strict_archive_abspath_parser, strict_archive_abspath_pattern
+from plexus.common.utils.strutils import strict_archive_relpath_parser, strict_archive_relpath_pattern
 from plexus.common.utils.strutils import strict_relpath_parser, strict_relpath_pattern
 from plexus.common.utils.strutils import topic_parser, topic_pattern
 from plexus.common.utils.strutils import vin_code_parser, vin_code_pattern
@@ -377,6 +379,154 @@ class StrUtilsTest(unittest.TestCase):
         with self.assertRaises(pp.ParseException):
             strict_abspath_parser.parse_string(data, parse_all=True)
 
+    data_strict_archive_relpath_pattern = [
+        ("archive.zip",),
+        ("directory/archive.zip",),
+        ("directory/dummy/archive.zip",),
+        ("directory/dummy/path/archive.zip",),
+        ("directory/dummy/path/to/archive.zip",),
+        ("directory/dummy/path_to-archive.zip",),
+        ("directory/dummy/.path_to-archive.zip",),
+        ("archive.zip#",),
+        ("archive.zip#directory",),
+        ("archive.zip#directory/",),
+        ("directory/archive.zip#directory/dummy",),
+        ("directory/archive.zip#directory/dummy/",),
+        ("directory/dummy/archive.zip#directory/dummy/path",),
+        ("directory/dummy/path/archive.zip#directory/dummy/path/to",),
+        ("directory/dummy/path/to/archive.zip#directory/dummy/path/to/file.txt",),
+        ("directory/dummy/path_to-archive.zip#directory/dummy/path_to-file.txt.",),
+        ("directory/dummy/.path_to-archive.zip#directory/dummy/.path_to-file.txt",),
+    ]
+
+    @ddt.idata(data_strict_archive_relpath_pattern)
+    @ddt.unpack
+    def test_strict_archive_relpath_pattern(self, data):
+        self.assertIsNotNone(strict_archive_relpath_pattern.match(data))
+        self.assertIsNotNone(strict_archive_relpath_parser.parse_string(data, parse_all=True))
+
+    data_strict_archive_relpath_pattern__bad_cases = [
+        ("/archive.zip",),
+        ("/directory/archive.zip",),
+        ("/directory/dummy/archive.zip",),
+        ("/directory/dummy/path/archive.zip",),
+        ("/directory/dummy/path/to/archive.zip",),
+        ("/directory/dummy/path_to-archive.zip",),
+        ("/directory/dummy/.path_to-archive.zip",),
+        ("/archive.zip#directory",),
+        ("/archive.zip#directory/",),
+        ("/directory/archive.zip#directory/dummy",),
+        ("/directory/archive.zip#directory/dummy/",),
+        ("/directory/dummy/archive.zip#directory/dummy/path",),
+        ("/directory/dummy/path/archive.zip#directory/dummy/path/to",),
+        ("/directory/dummy/path/to/archive.zip#directory/dummy/path/to/file.txt",),
+        ("/directory/dummy/path_to-archive.zip#directory/dummy/path_to-file.txt.",),
+        ("/directory/dummy/.path_to-archive.zip#directory/dummy/.path_to-file.txt",),
+        ("archive.zip/",),
+        ("directory/archive.zip/",),
+        ("directory/dummy/archive.zip/",),
+        ("directory/dummy/path/archive.zip/",),
+        ("directory/dummy/path/to/archive.zip/",),
+        ("directory/dummy/path_to-archive.zip/",),
+        ("directory/dummy/.path_to-archive.zip/",),
+        ("archive.zip#/directory",),
+        ("archive.zip#/directory/",),
+        ("directory/archive.zip#/directory/dummy",),
+        ("directory/archive.zip#/directory/dummy/",),
+        ("directory/dummy/archive.zip#/directory/dummy/path",),
+        ("directory/dummy/path/archive.zip#/directory/dummy/path/to",),
+        ("directory/dummy/path/to/archive.zip#/directory/dummy/path/to/file.txt",),
+        ("directory/dummy/path_to-archive.zip#/directory/dummy/path_to-file.txt.",),
+        ("directory/dummy/.path_to-archive.zip#/directory/dummy/.path_to-file.txt",),
+        ("directory/archive.zip#directory/./dummy",),
+        ("directory/archive.zip#directory/../dummy",),
+        ("directory/archive.zip#directory/.../dummy",),
+        ("directory/archive.zip#directory/\t/dummy",),
+        ("directory/archive.zip#directory/\r/dummy",),
+        ("directory/archive.zip#directory/\n/dummy",),
+    ]
+
+    @ddt.idata(data_strict_archive_relpath_pattern__bad_cases)
+    @ddt.unpack
+    def test_strict_archive_relpath_pattern__bad_cases(self, data):
+        self.assertIsNone(strict_archive_relpath_pattern.match(data))
+        with self.assertRaises(pp.ParseException):
+            strict_archive_relpath_parser.parse_string(data, parse_all=True)
+
+    data_strict_archive_abspath_pattern = [
+        ("/archive.zip",),
+        ("/directory/archive.zip",),
+        ("/directory/dummy/archive.zip",),
+        ("/directory/dummy/path/archive.zip",),
+        ("/directory/dummy/path/to/archive.zip",),
+        ("/directory/dummy/path_to-archive.zip",),
+        ("/directory/dummy/.path_to-archive.zip",),
+        ("/archive.zip#",),
+        ("/archive.zip#directory",),
+        ("/archive.zip#directory/",),
+        ("/directory/archive.zip#directory/dummy",),
+        ("/directory/archive.zip#directory/dummy/",),
+        ("/directory/dummy/archive.zip#directory/dummy/path",),
+        ("/directory/dummy/path/archive.zip#directory/dummy/path/to",),
+        ("/directory/dummy/path/to/archive.zip#directory/dummy/path/to/file.txt",),
+        ("/directory/dummy/path_to-archive.zip#directory/dummy/path_to-file.txt.",),
+        ("/directory/dummy/.path_to-archive.zip#directory/dummy/.path_to-file.txt",),
+    ]
+
+    @ddt.idata(data_strict_archive_abspath_pattern)
+    @ddt.unpack
+    def test_strict_archive_abspath_pattern(self, data):
+        self.assertIsNotNone(strict_archive_abspath_pattern.match(data))
+        self.assertIsNotNone(strict_archive_abspath_parser.parse_string(data, parse_all=True))
+
+    data_strict_archive_abspath_pattern__bad_cases = [
+        ("archive.zip",),
+        ("directory/archive.zip",),
+        ("directory/dummy/archive.zip",),
+        ("directory/dummy/path/archive.zip",),
+        ("directory/dummy/path/to/archive.zip",),
+        ("directory/dummy/path_to-archive.zip",),
+        ("directory/dummy/.path_to-archive.zip",),
+        ("archive.zip#directory",),
+        ("archive.zip#directory/",),
+        ("directory/archive.zip#directory/dummy",),
+        ("directory/archive.zip#directory/dummy/",),
+        ("directory/dummy/archive.zip#directory/dummy/path",),
+        ("directory/dummy/path/archive.zip#directory/dummy/path/to",),
+        ("directory/dummy/path/to/archive.zip#directory/dummy/path/to/file.txt",),
+        ("directory/dummy/path_to-archive.zip#directory/dummy/path_to-file.txt.",),
+        ("directory/dummy/.path_to-archive.zip#directory/dummy/.path_to-file.txt",),
+        ("/archive.zip/",),
+        ("/directory/archive.zip/",),
+        ("/directory/dummy/archive.zip/",),
+        ("/directory/dummy/path/archive.zip/",),
+        ("/directory/dummy/path/to/archive.zip/",),
+        ("/directory/dummy/path_to-archive.zip/",),
+        ("/directory/dummy/.path_to-archive.zip/",),
+        ("/archive.zip#/directory",),
+        ("/archive.zip#/directory/",),
+        ("/directory/archive.zip#/directory/dummy",),
+        ("/directory/archive.zip#/directory/dummy/",),
+        ("/directory/dummy/archive.zip#/directory/dummy/path",),
+        ("/directory/dummy/path/archive.zip#/directory/dummy/path/to",),
+        ("/directory/dummy/path/to/archive.zip#/directory/dummy/path/to/file.txt",),
+        ("/directory/dummy/path_to-archive.zip#/directory/dummy/path_to-file.txt.",),
+        ("/directory/dummy/.path_to-archive.zip#/directory/dummy/.path_to-file.txt",),
+        ("/directory/archive.zip#directory/./dummy",),
+        ("/directory/archive.zip#directory/../dummy",),
+        ("/directory/archive.zip#directory/.../dummy",),
+        ("/directory/archive.zip#directory/\t/dummy",),
+        ("/directory/archive.zip#directory/\r/dummy",),
+        ("/directory/archive.zip#directory/\n/dummy",),
+    ]
+
+    @ddt.idata(data_strict_archive_abspath_pattern__bad_cases)
+    @ddt.unpack
+    def test_strict_archive_abspath_pattern__bad_cases(self, data):
+        self.assertIsNone(strict_archive_abspath_pattern.match(data))
+        with self.assertRaises(pp.ParseException):
+            strict_archive_abspath_parser.parse_string(data, parse_all=True)
+
     data_email_address_pattern = [
         ("someone@dummy.com",),
         ("some.one@dummy.com",),