duplicity 3.0.6.dev11__tar.gz → 3.0.6.dev12__tar.gz

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/CHANGELOG.md

@@ -1,7 +1,23 @@
 # Changelog
 
 
-## rel.3.0.6.dev11 (2025-10-16)
+## (unreleased)
+
+### Changes
+
+* Misc build tools upgrades. [Kenneth Loafman]
+
+* Add error message to raw assert statements. [Kenneth Loafman]
+
+### Fix
+
+* 'duplicity incremental' attempts to fetch remote manifest which is not
+needed for the current backup. [Kenneth Loafman]
+
+    Fixes #891
+
+
+## rel.3.0.6.dev11 (2025-10-19)
 
 ### New
 
@@ -9,6 +25,8 @@
 
 ### Changes
 
+* Update CHANGELOG.md. [Kenneth Loafman]
+
 * Remove may fail py3.14. [Kenneth Loafman]
 
 * Use python:314 not -rc. [Kenneth Loafman]

{duplicity-3.0.6.dev11/duplicity.egg-info → duplicity-3.0.6.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duplicity
-Version: 3.0.6.dev11
+Version: 3.0.6.dev12
 Summary: Encrypted backup using rsync algorithm
 Author-email: Kenneth Loafman <kenneth@loafman.com>
 Maintainer: Edgar Soldin, Thomas Laubrock

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/__init__.py

@@ -21,7 +21,7 @@
 
 import gettext
 
-__version__: str = "3.0.6.dev11"
-__reldate__: str = "October 19, 2025"
+__version__: str = "3.0.6.dev12"
+__reldate__: str = "October 25, 2025"
 
 gettext.install("duplicity", names=["ngettext"])

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/backend.py

@@ -677,7 +677,9 @@ class BackendWrapper(object):
         """
         Delete each filename in filename_list, in order if possible.
         """
-        assert not isinstance(filename_list, bytes)
+        assert not isinstance(
+            filename_list, bytes
+        ), "filename_list must be an iterable of filenames (not a byte string)"
         if hasattr(self.backend, "_delete_list"):
             self._do_delete_list(filename_list)
         elif hasattr(self.backend, "_delete"):
@@ -777,5 +779,5 @@ class BackendWrapper(object):
         """
         fin = self.get_fileobj_read(filename, parseresults)
         buf = fin.read()
-        assert not fin.close()
+        assert not fin.close(), "fin failed to close"
         return buf

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/backends/dpbxbackend.py

@@ -307,7 +307,7 @@ Exception: {str(e)}"""
                     retry_number = config.num_retries
 
                     if not is_eof:
-                        assert len(buf) != 0
+                        assert len(buf) != 0, "buffer should not be empty"
                         log.Debug(
                             f"dpbx,files_upload_sesssion_append([{len(buf)} bytes], "
                             f"offset={int(upload_cursor.offset)})"

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/backends/gdocsbackend.py

@@ -112,7 +112,7 @@ class GDocsBackend(duplicity.backend.Backend):
                 f"Failed to initialize upload of file '{source_path.get_filename()}' "
                 f"to remote folder '{self.folder.title.text}'"
             )
-        assert not file.close()
+        assert not file.close(), "file failed to close"
 
     def _get(self, remote_filename, local_path):
         entries = self._fetch_entries(

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/backends/webdavbackend.py

@@ -428,7 +428,7 @@ class WebDAVBackend(duplicity.backend.Backend):
             response = self.request("GET", url)
             if response.status == 200:
                 shutil.copyfileobj(response, target_file)
-                assert not target_file.close()
+                assert not target_file.close(), "target_file failed to close"
                 response.close()
             else:
                 status = response.status

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/backends/xorrisobackend.py

@@ -254,7 +254,7 @@ class Xorriso:
         """
         Copy file to the ISO image. Does not commit the changes yet.
         """
-        assert isinstance(files, list)
+        assert isinstance(files, list), "should be a list of files"
 
         stdout, stderr = self.__send_cmd(
             "-cpr",
@@ -270,7 +270,7 @@ class Xorriso:
         """
         Remove a list of files from the image. Does not commit the changes yet.
         """
-        assert isinstance(files, list)
+        assert isinstance(files, list), "should be a list of files"
 
         if not files:
             return
@@ -285,9 +285,9 @@ class Xorriso:
         """
         Extract files from the ISO image.
         """
-        assert isinstance(files, list)
+        assert isinstance(files, list), "should be a list of files"
 
-        assert not os.path.exists(dest) or os.path.isfile(dest)
+        assert not os.path.exists(dest) or os.path.isfile(dest), "dest must be a directory"
 
         if len(files) == 0:
             return
@@ -365,7 +365,7 @@ class XorrisoBackend(duplicity.backend.Backend):
         self.xorriso = Xorriso(device=self.device, xorriso_path=xorriso_cmd, xorriso_args=self.xorriso_args)
 
     def _put(self, source_path, remote_filename):
-        assert not os.path.isdir(source_path.name.decode("utf8"))
+        assert not os.path.isdir(source_path.name.decode("utf8")), "source_path must be a file"
         source_path.setdata()
         source_size = source_path.getsize()
         progress.report_transfer(0, source_size)

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/cli_main.py

@@ -317,7 +317,7 @@ def process_command_line(cmdline_list):
                     log.ErrorCode.verify_dir_doesnt_exist,
                 )
         else:
-            assert config.action in ("full", "inc")
+            assert config.action in ("full", "inc"), "action must be full or inc"
             if not local_path.exists():
                 log.FatalError(
                     _(f"Backup source directory {local_path.uc_name} does not exist."),

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/diffdir.py

@@ -111,7 +111,7 @@ def get_delta_path(new_path, sig_path, sigTarFile=None):
     Return new delta_path which, when read, writes sig to sig_fileobj,
     if sigTarFile is not None
     """
-    assert new_path
+    assert new_path, "new_path must not be None or falsy when computing delta"
     if sigTarFile:
         ti = new_path.get_tarinfo()
         index = new_path.index
@@ -502,7 +502,7 @@ class TarBlockIter(object):
         """
         Turn next value of input_iter into a TarBlock
         """
-        assert not self.process_waiting
+        assert not self.process_waiting, "process_waiting should be False before starting a new process"
         raise NotImplementedError("'process' not implemented.")
 
     def process_continued(self):
@@ -512,7 +512,7 @@ class TarBlockIter(object):
         If processing val above would produce more than one TarBlock,
         get the rest of them by calling process_continue.
         """
-        assert self.process_waiting
+        assert self.process_waiting, "process_continued called without a waiting process to continue"
         raise NotImplementedError("'process_continues' not implemented.")
 
     def __next__(self):
@@ -662,7 +662,7 @@ class DeltaTarBlockIter(TarBlockIter):
             if not delta_ropath.type:
                 add_prefix(ti, r"deleted")
             else:
-                assert delta_ropath.difftype == "snapshot"
+                assert delta_ropath.difftype == "snapshot", "Expected snapshot difftype for fileless delta_ropath"
                 add_prefix(ti, r"snapshot")
             return self.tarinfo2tarblock(index, ti)
 
@@ -707,7 +707,7 @@ class DeltaTarBlockIter(TarBlockIter):
         """
         Return next volume in multivol diff or snapshot
         """
-        assert self.process_waiting
+        assert self.process_waiting, "No multivolume process is waiting; cannot continue"
         ropath = self.process_ropath
         ti, index = ropath.get_tarinfo(), ropath.index
         ti.name = f"{self.process_prefix}/{int(self.process_next_vol_number)}"
@@ -738,7 +738,7 @@ def write_block_iter(block_iter, out_obj):
     for block in block_iter:
         fp.write(block.data)
     fp.write(block_iter.get_footer())
-    assert not fp.close()
+    assert not fp.close(), "fp failed to close"
     if isinstance(out_obj, Path):
         out_obj.setdata()
 

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/dup_collections.py

@@ -138,7 +138,9 @@ class BackupSet(object):
         elif pr.manifest:
             self.set_manifest(filename)
         else:
-            assert pr.volume_number is not None
+            assert (
+                pr.volume_number is not None
+            ), f"Missing volume_number in ParseResults for file {os.fsdecode(filename)}"
             assert pr.volume_number not in self.volume_name_dict, (
                 f"Volume {int(pr.volume_number)} is already in the volume list as "
                 f"{os.fsdecode(self.volume_name_dict[pr.volume_number])}. "
@@ -156,7 +158,7 @@ class BackupSet(object):
         @param pr: parse results
         @type pr: ParseResults
         """
-        assert not self.info_set
+        assert not self.info_set, "BackupSet info already set; cannot set twice"
         self.type = pr.type
         self.time = pr.time
         self.start_time = pr.start_time
@@ -198,9 +200,6 @@ class BackupSet(object):
         """
         Add local and remote manifest filenames to backup set
         """
-        assert (
-            not self.remote_manifest_name
-        ), f"Cannot set filename of remote manifest to {remote_filename}; already set to {self.remote_manifest_name}."
         self.remote_manifest_name = remote_filename
 
         local_filename_list = config.archive_dir_path.listdir()
@@ -302,7 +301,7 @@ class BackupSet(object):
         """
         Return manifest object by reading local manifest file
         """
-        assert self.local_manifest_path
+        assert self.local_manifest_path, "Local manifest path is not set for this BackupSet"
         manifest_buffer = self.local_manifest_path.get_data()
         log.Info(_(f"Processing local manifest {self.local_manifest_path.uc_name} ({len(manifest_buffer)})"))
         return manifest.Manifest().from_string(manifest_buffer)
@@ -353,7 +352,7 @@ class BackupSet(object):
         """
         Return sorted list of (remote) filenames of files in set
         """
-        assert self.info_set
+        assert self.info_set, "BackupSet info must be set before retrieving filenames"
         volume_num_list = sorted(self.volume_name_dict.keys())
         volume_filenames = [self.volume_name_dict[x] for x in volume_num_list]
         if self.remote_manifest_name:
@@ -421,9 +420,11 @@ class BackupChain(object):
         """
         Add full backup set
         """
-        assert not self.fullset and isinstance(fullset, BackupSet)
+        assert not self.fullset and isinstance(
+            fullset, BackupSet
+        ), "Full backup set must be unset and argument must be a BackupSet instance"
         self.fullset = fullset
-        assert fullset.time
+        assert fullset.time, "Full backup set must have a valid 'time' attribute"
         self.start_time, self.end_time = fullset.time, fullset.time
 
     def add_inc(self, incset):
@@ -457,7 +458,7 @@ class BackupChain(object):
                 dup_time.timetopretty(incset.end_time),
             )
         )
-        assert self.end_time
+        assert self.end_time, "BackupChain end_time must be set after adding an incremental set"
         return True
 
     def delete(self, keep_full=False):
@@ -654,7 +655,7 @@ class SignatureChain(object):
         Return ordered list of signature fileobjs opened for reading,
         optionally at a certain time
         """
-        assert self.fullsig
+        assert self.fullsig, "SignatureChain fullsig must be set before accessing related data"
         if self.archive_dir_path:  # local
 
             def filename_to_fileobj(filename):
@@ -677,7 +678,7 @@ class SignatureChain(object):
             if not keep_full:
                 self.archive_dir_path.append(self.fullsig).delete()
         else:
-            assert self.backend
+            assert self.backend, "Backend must be set before performing this operation"
             inclist_copy = self.inclist[:]
             inclist_copy.reverse()
             if not keep_full:
@@ -883,7 +884,7 @@ class CollectionsStatus(object):
         """
         Log various error messages if find incomplete/orphaned files
         """
-        assert self.values_set
+        assert self.values_set, "CollectionsStatus values must be set (call set_values) before warning/reporting"
 
         def missing_to_log_info(s):
             """
@@ -1013,7 +1014,7 @@ class CollectionsStatus(object):
                 chains.append(new_chain)
                 log.Debug(_("Found backup chain %s") % (new_chain.short_desc()))
             else:
-                assert set.type == "inc"
+                assert set.type == "inc", f"Expected incremental set type 'inc', got {set.type!r} for set {set}"
                 for chain in chains:
                     if chain.add_inc(set):
                         log.Debug(_("Added set %s to pre-existing chain %s") % (set.get_timestr(), chain.short_desc()))
@@ -1079,7 +1080,9 @@ class CollectionsStatus(object):
             if pr:
                 if pr.type == "full-sig":
                     new_chain = get_new_sigchain()
-                    assert new_chain.add_filename(filename, pr)
+                    assert new_chain.add_filename(
+                        filename, pr
+                    ), f"Failed to add signature file {os.fsdecode(filename)} to new signature chain"
                     chains.append(new_chain)
                 elif pr.type == "new-sig":
                     new_sig_filenames.append(filename)
@@ -1116,7 +1119,7 @@ class CollectionsStatus(object):
             if len(chain_list) == 1:
                 sorted_chain_list.append(chain_list[0])
             else:
-                assert len(chain_list) == 2
+                assert len(chain_list) == 2, f"Expected exactly 2 chains with equal end_time, got {len(chain_list)}"
                 if chain_list[0].backend:  # is remote, goes first
                     sorted_chain_list.append(chain_list[0])
                     sorted_chain_list.append(chain_list[1])
@@ -1190,7 +1193,9 @@ class CollectionsStatus(object):
         recognizable as a duplicity file, but isn't part of some
         complete backup set, or current signature chain.
         """
-        assert self.values_set
+        assert (
+            self.values_set
+        ), "CollectionsStatus values must be initialized via set_values() before calling get_extraneous()"
         local_filenames = []
         remote_filenames = []
         ext_containers = self.orphaned_backup_sets + self.incomplete_backup_sets + self.missing_difftar_sets
@@ -1219,7 +1224,7 @@ class CollectionsStatus(object):
         than t, and set B is an incremental based on A which is newer
         than t, then the time of set A will not be returned.
         """
-        assert self.values_set
+        assert self.values_set, "CollectionsStatus values must be set before calling get_chains_older_than()"
         old_chains = []
         for chain in self.all_backup_chains:
             if chain.end_time < t and (
@@ -1239,7 +1244,7 @@ class CollectionsStatus(object):
         than t, and set B is an incremental based on A which is newer
         than t, then the time of set A will not be returned.
         """
-        assert self.values_set
+        assert self.values_set, "CollectionsStatus values must be set before calling get_signature_chains_older_than()"
         old_chains = []
         for chain in self.all_sig_chains:
             if chain.end_time < t and (
@@ -1283,8 +1288,8 @@ class CollectionsStatus(object):
         a valid input). Thus the second-to-last is obtained with n=2
         rather than n=1.
         """
-        assert self.values_set
-        assert n > 0
+        assert self.values_set, "CollectionsStatus values must be set before calling get_nth_last_backup_chain()"
+        assert n > 0, f"n must be > 0 (1 = latest chain); got n={n}"
 
         if len(self.all_backup_chains) < n:
             return None
@@ -1318,7 +1323,7 @@ class CollectionsStatus(object):
         returns the times of sets which are old but part of the chains
         where the newer end of the chain is newer than t.
         """
-        assert self.values_set
+        assert self.values_set, "CollectionsStatus values must be set before calling get_older_than_required()"
         new_chains = [c for c in self.all_backup_chains if c.end_time >= t]
         result_sets = []
         for chain in new_chains:

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/dup_main.py

@@ -580,7 +580,7 @@ def get_man_fileobj(backup_type):
     @rtype: fileobj
     @return: fileobj opened for writing
     """
-    assert backup_type == "full" or backup_type == "inc"
+    assert backup_type == "full" or backup_type == "inc", f"backup_type must be 'full' or 'inc', got {backup_type!r}"
 
     part_man_filename = file_naming.get(backup_type, manifest=True, partial=True)
     perm_man_filename = file_naming.get(backup_type, manifest=True)
@@ -605,7 +605,7 @@ def get_sig_fileobj(sig_type):
     @rtype: fileobj
     @return: fileobj opened for writing
     """
-    assert sig_type in ["full-sig", "new-sig"]
+    assert sig_type in ["full-sig", "new-sig"], f"sig_type must be 'full-sig' or 'new-sig', got {sig_type!r}"
 
     part_sig_filename = file_naming.get(sig_type, gzipped=False, partial=True)
     perm_sig_filename = file_naming.get(sig_type, gzipped=True)
@@ -630,7 +630,7 @@ def get_stat_fileobj(stat_type):
     @rtype: fileobj
     @return: fileobj opened for writing
     """
-    assert stat_type in ["full-stat", "inc-stat"]
+    assert stat_type in ["full-stat", "inc-stat"], f"stat_type must be 'full-stat' or 'inc-stat', got {stat_type!r}"
 
     part_stat_filename = file_naming.get(stat_type, gzipped=False, partial=True)
     perm_stat_filename = file_naming.get(stat_type, gzipped=True)
@@ -894,7 +894,10 @@ def restore_get_patched_rop_iter(col_stats):
         index = ()
     time = config.restore_time or dup_time.curtime
     backup_chain = col_stats.get_backup_chain_at_time(time)
-    assert backup_chain, col_stats.all_backup_chains
+    assert backup_chain, (
+        f"No backup chain found for restore time {dup_time.timetostring(time)}; "
+        f"available chains: {col_stats.all_backup_chains}"
+    )
     backup_setlist = backup_chain.get_sets_at_time(time)
     num_vols = 0
     for s in backup_setlist:
@@ -1113,7 +1116,9 @@ def remove_all_but_n_full(col_stats):
     @rtype: void
     @return: void
     """
-    assert config.keep_chains is not None
+    assert (
+        config.keep_chains is not None
+    ), "config.keep_chains (from --keep-chains) must be set before removing old backups"
 
     config.remove_time = col_stats.get_nth_last_full_backup_time(config.keep_chains)
 
@@ -1130,7 +1135,7 @@ def remove_old(col_stats):
     @rtype: void
     @return: void
     """
-    assert config.remove_time is not None
+    assert config.remove_time is not None, "config.remove_time must be set before removing old backups"
 
     def set_times_str(setlist):
         """Return string listing times of sets in setlist"""
@@ -1227,7 +1232,7 @@ def sync_archive(col_stats):
         """
         if config.metadata_sync_mode == "full":
             return True
-        assert config.metadata_sync_mode == "partial"
+        assert config.metadata_sync_mode == "partial", "metadata_sync_mode must be 'partial' when not in full sync mode"
         parsed = file_naming.parse(filename)
         try:
             target_chain = col_stats.get_backup_chain_at_time(config.restore_time or dup_time.curtime)
@@ -1448,7 +1453,7 @@ def check_last_manifest(col_stats):
     @rtype: void
     @return: void
     """
-    assert col_stats.all_backup_chains
+    assert col_stats.all_backup_chains, "No backup chains found; cannot check last manifest without any chains present"
     last_backup_set = col_stats.all_backup_chains[-1].get_last()
     # check remote manifest only if we can decrypt it (see #1729796)
     last_backup_set.check_manifests(check_remote=config.check_remote)

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/dup_temp.py

@@ -138,7 +138,7 @@ class TempDupPath(path.DupPath):
         """
         Returns a fileobj.  When that is closed, delete file
         """
-        assert mode == "rb"  # Why write a file and then close it immediately?
+        assert mode == "rb", "wrong mode for open_with_delete"
         fh = FileobjHooked(path.DupPath.open(self, mode))
         fh.addhook(self.delete)
         return fh
@@ -187,7 +187,7 @@ class FileobjHooked(object):
         """
         We have achieved the first checkpoint, make file visible and permanent.
         """
-        assert not config.restart
+        assert not config.restart, "may not restart after checkpoint"
         self.tdp.rename(self.dirpath.append(self.partname))
         self.fileobj.flush()
         del self.hooklist[0]
@@ -245,7 +245,7 @@ class FileobjHooked(object):
         """
         Close fileobj, running hooks right afterwards
         """
-        assert not self.fileobj.close()
+        assert not self.fileobj.close(), "self.fileobj failed to close"
         for hook in self.hooklist:
             hook()
 

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/dup_time.py

@@ -76,14 +76,14 @@ def setcurtime(time_in_secs=None):
     """Sets the current time in curtime and curtimestr"""
     global curtime, curtimestr
     t = time_in_secs or int(time.time())
-    assert isinstance(t, int)
+    assert isinstance(t, int), "curtime must be an integer"
     curtime, curtimestr = t, timetostring(t)
 
 
 def setprevtime(time_in_secs):
     """Sets the previous time in prevtime and prevtimestr"""
     global prevtime, prevtimestr
-    assert isinstance(time_in_secs, int), prevtime
+    assert isinstance(time_in_secs, int), "prevtime must be an integer"
     prevtime, prevtimestr = time_in_secs, timetostring(time_in_secs)
 
 
@@ -111,12 +111,12 @@ def stringtotime(timestring):
             # old format for filename time
             year, month, day = list(map(int, date.split("-")))
             hour, minute, second = list(map(int, daytime.split(config.time_separator)))
-        assert 1900 < year < 2100, year
-        assert 1 <= month <= 12
-        assert 1 <= day <= 31
-        assert 0 <= hour <= 23
-        assert 0 <= minute <= 59
-        assert 0 <= second <= 61  # leap seconds
+        assert 1900 < year < 2100, f"year {year} out of supported range (1901..2099)"
+        assert 1 <= month <= 12, f"month {month} out of range (1..12)"
+        assert 1 <= day <= 31, f"day {day} out of range (1..31)"
+        assert 0 <= hour <= 23, f"hour {hour} out of range (0..23)"
+        assert 0 <= minute <= 59, f"minute {minute} out of range (0..59)"
+        assert 0 <= second <= 61, f"second {second} out of range (0..61, allowing leap seconds)"  # leap seconds
         # We want to return the time in units of seconds since the
         # epoch. Unfortunately the only functin that does this
         # works in terms of the current timezone and we have a
@@ -230,8 +230,8 @@ def gettzd(dstflag):
         return "Z"  # time is already in UTC
 
     hours, minutes = list(map(abs, divmod(offset, 60)))
-    assert 0 <= hours <= 23
-    assert 0 <= minutes <= 59
+    assert 0 <= hours <= 23, f"hours component {hours} out of range (0..23)"
+    assert 0 <= minutes <= 59, f"minutes component {minutes} out of range (0..59)"
     return f"{prefix}{int(hours):02}{config.time_separator}{int(minutes):02}"
 
 
@@ -239,8 +239,12 @@ def tzdtoseconds(tzd):
     """Given w3 compliant TZD, return how far ahead UTC is"""
     if tzd == "Z":
         return 0
-    assert len(tzd) == 6  # only accept forms like +08:00 for now
-    assert (tzd[0] == "-" or tzd[0] == "+") and tzd[3] == config.time_separator
+    assert (
+        len(tzd) == 6
+    ), "TZD must be 6 characters in the form ±HH:MM (e.g., +08:00)"  # only accept forms like +08:00 for now
+    assert (tzd[0] == "-" or tzd[0] == "+") and (
+        tzd[3] == config.time_separator
+    ), "TZD must start with +/- and include the correct time separator at position 3 (±HH:MM)"
     return -60 * (60 * int(tzd[:3]) + int(tzd[4:]))
 
 
@@ -248,10 +252,10 @@ def cmp(time1, time2):
     """Compare time1 and time2 and return -1, 0, or 1"""
     if isinstance(time1, (str, string)):
         time1 = stringtotime(time1)
-        assert time1 is not None
+        assert time1 is not None, "time1 string could not be parsed into a valid timestamp"
     if isinstance(time2, (str, str)):
         time2 = stringtotime(time2)
-        assert time2 is not None
+        assert time2 is not None, "time2 string could not be parsed into a valid timestamp"
 
     if time1 < time2:
         return -1

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/file_naming.py

@@ -253,14 +253,16 @@ def get(
     can be given with the full and inc types.  If manifest is true the
     filename is of a full or inc manifest file.
     """
-    assert dup_time.curtimestr
+    assert dup_time.curtimestr, "dup_time.curtimestr must be set before generating filenames (call setcurtime)"
     if encrypted:
         gzipped = False
     suffix = get_suffix(encrypted, gzipped)
     part_string = b".part" if partial else b""
     if type == "full-sig" or type == "new-sig":
-        assert not volume_number and not manifest
-        assert not (volume_number and part_string)
+        assert not volume_number and not manifest, "volume_number and manifest must not be set for signature files"
+        assert not (
+            volume_number and part_string
+        ), "volume_number and partial (.part) cannot be combined for signature files"
         if type == "full-sig":
             return (
                 config.file_prefix
@@ -280,8 +282,10 @@ def get(
                 )
             )
     elif type == "full-stat" or type == "inc-stat":
-        assert not volume_number and not manifest
-        assert not (volume_number and part_string)
+        assert not volume_number and not manifest, "volume_number and manifest must not be set for statistics files"
+        assert not (
+            volume_number and part_string
+        ), "volume_number and partial (.part) cannot be combined for statistics files"
         type_suffix = b"jsonstat"
         if type == "full-stat":
             main_name = b"duplicity-full"
@@ -299,8 +303,8 @@ def get(
             + b"%s.%s.%s%s%s" % (main_name, timestamp, type_suffix, part_string, suffix)
         )
     else:
-        assert volume_number or manifest
-        assert not (volume_number and manifest)
+        assert volume_number or manifest, "Either 'volume_number' must be provided or 'manifest' must be True"
+        assert not (volume_number and manifest), "'volume_number' and 'manifest' are mutually exclusive"
 
         prefix = config.file_prefix
 
@@ -329,7 +333,7 @@ def get(
                 suffix,
             )
         else:
-            assert 0
+            assert 0, f"Unknown file type '{type}' for constructing name"
 
 
 def parse(filename):
@@ -523,15 +527,24 @@ class ParseResults:
         compressed=None,
         partial=False,
     ):
-        assert type in ["full-sig", "new-sig", "inc", "full", "full-stat", "inc-stat"]
+        assert type in ["full-sig", "new-sig", "inc", "full", "full-stat", "inc-stat"], (
+            f"Invalid duplicity filename type '{type}'. Expected one of:"
+            f" ['full-sig', 'new-sig', 'inc', 'full', 'full-stat', 'inc-stat']"
+        )
 
         self.type = type
         if type in ["inc", "full"]:
-            assert manifest or volume_number
+            assert manifest or volume_number, (
+                "ParseResults for 'full' or 'inc' requires either 'manifest' flag to be True "
+                f"or a 'volume_number' integer. Got manifest={manifest}, volume_number={volume_number}."
+            )
         if type in ["inc", "new-sig", "inc-stat"]:
-            assert start_time and end_time
+            assert start_time and end_time, (
+                f"ParseResults for type '{type}' requires both start_time and end_time; "
+                f"got start_time={start_time}, end_time={end_time}."
+            )
         else:
-            assert time
+            assert time, f"ParseResults for type '{type}' requires a single 'time' value; got time={time}."
 
         self.manifest = manifest
         self.volume_number = volume_number

{duplicity-3.0.6.dev11 → duplicity-3.0.6.dev12}/duplicity/globmatch.py

@@ -79,7 +79,7 @@ def select_fn_from_glob(glob_str, include, ignore_case=False):
 
     Note: including a folder implicitly includes everything within it.
     """
-    assert isinstance(glob_str, str)
+    assert isinstance(glob_str, str), f"glob_str must be a str (unicode), got {type(glob_str).__name__}: {glob_str!r}"
     glob_ends_w_slash = False
 
     if glob_str == "/":
@@ -170,7 +170,7 @@ def glob_to_regex(pat):
     """
     # Internal. Used by glob_get_sf, glob_get_prefix_res and unit tests.
 
-    assert isinstance(pat, str)
+    assert isinstance(pat, str), f"pat must be a str (unicode), got {type(pat).__name__}: {pat!r}"
 
     i, n, res = 0, len(pat), ""
     while i < n: