dar-backup 1.0.0.1__py3-none-any.whl → 1.0.1__py3-none-any.whl

dar_backup/manager.py

@@ -35,6 +35,7 @@ from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
 from dar_backup.util import setup_logging
 from dar_backup.util import CommandResult
+from dar_backup.util import get_config_file
 from dar_backup.util import get_logger
 from dar_backup.util import get_binary_info
 from dar_backup.util import show_version
@@ -47,6 +48,7 @@ from dar_backup.command_runner import CommandResult
 from dar_backup.util import backup_definition_completer, list_archive_completer, archive_content_completer, add_specific_archive_completer
 
 from datetime import datetime
+from sys import stderr
 from time import time
 from typing import Dict, List, NamedTuple, Tuple
 
@@ -492,7 +494,7 @@ def remove_specific_archive(archive: str, config_settings: ConfigSettings) -> in
 
 def build_arg_parser():
     parser = argparse.ArgumentParser(description="Creates/maintains `dar` database catalogs")
-    parser.add_argument('-c', '--config-file', type=str, help="Path to 'dar-backup.conf'", default='~/.config/dar-backup/dar-backup.conf')
+    parser.add_argument('-c', '--config-file', type=str, help="Path to 'dar-backup.conf'", default=None)
     parser.add_argument('--create-db', action='store_true', help='Create missing databases for all backup definitions')
     parser.add_argument('--alternate-archive-dir', type=str, help='Use this directory instead of BACKUP_DIR in config file')
     parser.add_argument('--add-dir', type=str, help='Add all archive catalogs in this directory to databases')
@@ -536,7 +538,12 @@ def main():
         show_version()
         sys.exit(0)
 
-    args.config_file = os.path.expanduser(os.path.expandvars(args.config_file))
+    config_settings_path = get_config_file(args)
+    if not (os.path.isfile(config_settings_path) and os.access(config_settings_path, os.R_OK)):
+        print(f"Config file {config_settings_path} must exist and be readable.", file=stderr)
+        raise SystemExit(127)
+    args.config_file = config_settings_path
+
     config_settings = ConfigSettings(args.config_file)
 
     if not os.path.dirname(config_settings.logfile_location):
@@ -554,7 +561,6 @@ def main():
     start_time = int(time())
     
     start_msgs.append((f"{show_scriptname()}:", about.__version__))
-    logger.info(f"START TIME: {start_time}")
     logger.debug(f"Command line: {get_invocation_command_line()}")
     logger.debug(f"`args`:\n{args}")
     logger.debug(f"`config_settings`:\n{config_settings}")

dar_backup/util.py

@@ -14,6 +14,7 @@ import locale
 import configparser
 import inspect
 import logging
+import json
 
 import os
 import re
@@ -23,12 +24,16 @@ import shutil
 import sys
 import threading
 import traceback
+import urllib.error
+import urllib.request
 
 import dar_backup.__about__ as about
 
 
+
 from argcomplete.completers import ChoicesCompleter
-from datetime import datetime
+from datetime import datetime, date
+from datetime import date 
 from dar_backup.config_settings import ConfigSettings
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
@@ -136,15 +141,29 @@ def get_logger(command_output_logger: bool = False) -> logging.Logger:
     return secondary_logger if command_output_logger else logger
 
 
+def _default_completer_logfile() -> str:
+    try:
+        uid = os.getuid()
+    except AttributeError:
+        uid = None
+    suffix = str(uid) if uid is not None else "unknown"
+    return f"/tmp/dar_backup_completer_{suffix}.log"
+
+
 # Setup completer logger only once
-def _setup_completer_logger(logfile="/tmp/dar_backup_completer.log"):
+def _setup_completer_logger(logfile: str = None):
     logger = logging.getLogger("completer")
     if not logger.handlers:
-        handler = logging.FileHandler(logfile)
-        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-        logger.setLevel(logging.DEBUG)
+        try:
+            logfile = logfile or _default_completer_logfile()
+            handler = logging.FileHandler(logfile)
+            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+            logger.setLevel(logging.DEBUG)
+        except Exception:
+            logger.addHandler(logging.NullHandler())
+            logger.setLevel(logging.DEBUG)
     return logger
 
 # Singleton logger for completer debugging
@@ -200,10 +219,80 @@ def show_version():
     print(f"{script_name} source code is here: https://github.com/per2jensen/dar-backup")
     print(about.__license__)
 
+
+def send_discord_message(
+    content: str,
+    config_settings: typing.Optional[ConfigSettings] = None,
+    timeout_seconds: int = 10
+) -> bool:
+    """
+    Send a message to a Discord webhook if configured either in the config file or via environment.
+
+    The environment varible DAR_BACKUP_DISCORD_WEBHOOK_URL, when set, takes precedence over the config file variable 
+    with the same name. If neither is defined, the function logs an info-level message and returns False.
+
+    Returns:
+        bool: True if the message was sent successfully, otherwise False.
+    """
+    log = get_logger()
+
+    config_webhook = getattr(config_settings, "dar_backup_discord_webhook_url", None) if config_settings else None
+    env_webhook = os.environ.get("DAR_BACKUP_DISCORD_WEBHOOK_URL")
+
+    webhook_url = env_webhook or config_webhook
+    source = "environment" if env_webhook else ("config file" if config_webhook else None)
+
+    if not webhook_url:
+        log and log.info("Discord message not sent: DAR_BACKUP_DISCORD_WEBHOOK_URL not configured.")
+        return False
+
+    payload = json.dumps({"content": content}).encode("utf-8")
+    user_agent = f"dar-backup/{about.__version__}"
+
+    request = urllib.request.Request(
+        webhook_url,
+        data=payload,
+        headers={
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": user_agent,
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(request, timeout=timeout_seconds):
+            pass
+        log and log.debug(f"Discord webhook message sent using {source}.")
+        return True
+    except urllib.error.HTTPError as exc:
+        # Attempt to read a short error body for diagnostics
+        body = None
+        try:
+            body = exc.read().decode(errors="replace")
+        except Exception:
+            body = None
+        detail = f" body='{body.strip()}'" if body else ""
+        message = f"Discord webhook HTTP error {exc.code}: {exc.reason}{detail}"
+        if log:
+            log.error(message)
+        else:
+            print(message, file=sys.stderr)
+    except Exception as exc:
+        message = f"Failed to send Discord webhook message: {exc}"
+        if log:
+            log.error(message)
+        else:
+            print(message, file=sys.stderr)
+
+    return False
+
+
 def extract_version(output):
     match = re.search(r'(\d+\.\d+(\.\d+)?)', output)
     return match.group(1) if match else "unknown"
 
+
 def get_binary_info(command):
     """
     Return information about a binary command.
@@ -428,16 +517,14 @@ def expand_path(path: str) -> str:
     return os.path.expanduser(os.path.expandvars(path))
 
 
-
 def backup_definition_completer(prefix, parsed_args, **kwargs):
-    config_path = getattr(parsed_args, 'config_file', '~/.config/dar-backup/dar-backup.conf')
-    config_path = expand_path(config_path)
-    config_file = os.path.expanduser(config_path)
     try:
+        config_file = get_config_file(parsed_args)
         config = ConfigSettings(config_file)
         backup_d_dir = os.path.expanduser(config.backup_d_dir)
         return [f for f in os.listdir(backup_d_dir) if f.startswith(prefix)]
     except Exception:
+        completer_logger.exception("backup_definition_completer failed")
         return []
 
 
@@ -450,46 +537,84 @@ def extract_backup_definition_fallback() -> str:
         str: The value of the --backup-definition argument if found, else an empty string.
     """
     comp_line = os.environ.get("COMP_LINE", "")
-    # Match both "--backup-definition VALUE" and "-d VALUE"
-    match = re.search(r"(--backup-definition|-d)\s+([^\s]+)", comp_line)
-    if match:
-        return match.group(2)
+    try:
+        tokens = shlex.split(comp_line)
+    except ValueError:
+        tokens = comp_line.split()
+
+    for i, token in enumerate(tokens):
+        if token in ("-d", "--backup-definition", "--backup-def"):
+            if i + 1 < len(tokens):
+                return tokens[i + 1]
+        elif token.startswith(("--backup-definition=", "--backup-def=", "-d=")):
+            return token.split("=", 1)[1]
     return ""
 
 
 
 
 def list_archive_completer(prefix, parsed_args, **kwargs):
-    import os
-    import configparser
-    from dar_backup.util import extract_backup_definition_fallback
+    try:
+        import os
+        import configparser
+        from dar_backup.util import extract_backup_definition_fallback
+
+        comp_line = os.environ.get("COMP_LINE", "")
+        if "cleanup" in comp_line and "--cleanup-specific-archives" not in comp_line:
+            return []
+
+        backup_def = (
+            getattr(parsed_args, "backup_definition", None)
+            or getattr(parsed_args, "backup_def", None)
+            or extract_backup_definition_fallback()
+        )
+        head, last = split_archive_list_prefix(prefix)
+        config_path = get_config_file(parsed_args)
+        if not os.path.exists(config_path):
+            return []
 
-    backup_def = getattr(parsed_args, "backup_definition", None) or extract_backup_definition_fallback()
-    config_path = getattr(parsed_args, "config_file", None) or "~/.config/dar-backup/dar-backup.conf"
+        config = configparser.ConfigParser()
+        config.read(config_path)
+        backup_dir = config.get("DIRECTORIES", "BACKUP_DIR", fallback="")
+        backup_dir = os.path.expanduser(os.path.expandvars(backup_dir))
 
-    config_path = os.path.expanduser(os.path.expandvars(config_path))
-    if not os.path.exists(config_path):
-        return []
+        if not os.path.isdir(backup_dir):
+            return []
 
-    config = configparser.ConfigParser()
-    config.read(config_path)
-    backup_dir = config.get("DIRECTORIES", "BACKUP_DIR", fallback="")
-    backup_dir = os.path.expanduser(os.path.expandvars(backup_dir))
+        files = os.listdir(backup_dir)
+        archive_re = re.compile(rf"^{re.escape(backup_def)}_.+_\d{{4}}-\d{{2}}-\d{{2}}\.1\.dar$") if backup_def else re.compile(r".+_\d{4}-\d{2}-\d{2}\.1\.dar$")
 
-    if not os.path.isdir(backup_dir):
-        return []
+        completions = []
+        for fname in files:
+            if not archive_re.match(fname):
+                continue
+            base = fname.rsplit(".1.dar", 1)[0]
+            if last and not base.startswith(last):
+                continue
+            if head:
+                completions.append(f"{head}, {base}")
+            else:
+                completions.append(base)
 
-    files = os.listdir(backup_dir)
-    archive_re = re.compile(rf"^{re.escape(backup_def)}_.+_\d{{4}}-\d{{2}}-\d{{2}}\.1\.dar$") if backup_def else re.compile(r".+_\d{4}-\d{2}-\d{2}\.1\.dar$")
+        completions = sorted(set(completions), key=sort_key)
+        return completions or ["[no matching archives]"]
+    except Exception:
+        completer_logger.exception("list_archive_completer failed")
+        return []
 
-    completions = [
-        f.rsplit(".1.dar", 1)[0]
-        for f in files
-        if archive_re.match(f)
-    ]
 
-    completions = sorted(set(completions), key=sort_key)
-    return completions or ["[no matching archives]"]
+def split_archive_list_prefix(prefix: str) -> tuple[str, str]:
+    """
+    Split a comma-separated archive list into (head, last).
+    Strips whitespace so completions don't include leading/trailing spaces.
+    """
+    if not prefix or "," not in prefix:
+        return ("", prefix.strip())
+    parts = [part.strip() for part in prefix.split(",")]
+    head_parts = [part for part in parts[:-1] if part]
+    head = ", ".join(head_parts)
+    last = parts[-1]
+    return (head, last)
 
 
 
@@ -511,6 +636,7 @@ def sort_key(archive_name: str):
         completer_logger.debug(f"Archive: {archive_name}, Def: {def_name}, Date: {date}")
         return (def_name, date)
     except Exception:
+        completer_logger.exception("sort_key failed")
         return (archive_name, datetime.min)
 
 
@@ -523,52 +649,56 @@ def archive_content_completer(prefix, parsed_args, **kwargs):
     Only entries found in the catalog database (via `dar_manager --list`) are shown.
     """
 
-    from dar_backup.config_settings import ConfigSettings
-    import subprocess
-    import re
-    import os
-    from datetime import datetime
-
-    # Expand config path
-    config_file = expand_path(getattr(parsed_args, "config_file", "~/.config/dar-backup/dar-backup.conf"))
-    config = ConfigSettings(config_file=config_file)
-    #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
-    db_dir = expand_path(getattr(config, 'manager_db_dir', None) or config.backup_dir)
-
-    # Which db files to inspect?
-    backup_def = getattr(parsed_args, "backup_def", None)
-    db_files = (
-        [os.path.join( db_dir, f"{backup_def}.db")]
-        if backup_def
-        else [os.path.join( db_dir, f) for f in os.listdir( db_dir) if f.endswith(".db")]
-    )
+    try:
+        from dar_backup.config_settings import ConfigSettings
+        import subprocess
+        import re
+        import os
+        from datetime import datetime
+
+        # Expand config path
+        config_file = get_config_file(parsed_args)
+        config = ConfigSettings(config_file=config_file)
+        #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
+        db_dir = expand_path(getattr(config, 'manager_db_dir', None) or config.backup_dir)
+
+        # Which db files to inspect?
+        backup_def = getattr(parsed_args, "backup_def", None)
+        db_files = (
+            [os.path.join( db_dir, f"{backup_def}.db")]
+            if backup_def
+            else [os.path.join( db_dir, f) for f in os.listdir( db_dir) if f.endswith(".db")]
+        )
 
-    completions = []
+        completions = []
 
-    for db_path in db_files:
-        if not os.path.exists(db_path):
-            continue
+        for db_path in db_files:
+            if not os.path.exists(db_path):
+                continue
 
-        try:
-            result = subprocess.run(
-                ["dar_manager", "--base", db_path, "--list"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.DEVNULL,
-                text=True,
-                check=True
-            )
-        except subprocess.CalledProcessError:
-            continue
+            try:
+                result = subprocess.run(
+                    ["dar_manager", "--base", db_path, "--list"],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                    text=True,
+                    check=True
+                )
+            except subprocess.CalledProcessError:
+                continue
 
-        for line in result.stdout.splitlines():
-            parts = line.strip().split("\t")
-            if len(parts) >= 3:
-                archive = parts[2].strip()
-                if archive.startswith(prefix):
-                    completions.append(archive)
+            for line in result.stdout.splitlines():
+                parts = line.strip().split("\t")
+                if len(parts) >= 3:
+                    archive = parts[2].strip()
+                    if archive.startswith(prefix):
+                        completions.append(archive)
 
-    completions = sorted(set(completions), key=sort_key)
-    return completions or ["[no matching archives]"]
+        completions = sorted(set(completions), key=sort_key)
+        return completions or ["[no matching archives]"]
+    except Exception:
+        completer_logger.exception("archive_content_completer failed")
+        return []
 
 
 
@@ -578,55 +708,59 @@ def add_specific_archive_completer(prefix, parsed_args, **kwargs):
     but not yet present in the <backup_def>.db catalog.
     If --backup-def is provided, restrict suggestions to that.
     """
-    from dar_backup.config_settings import ConfigSettings
-    import subprocess
-    import re
-    import os
-    from datetime import datetime
-
-    config_file = expand_path(getattr(parsed_args, "config_file", "~/.config/dar-backup/dar-backup.conf"))
-    config = ConfigSettings(config_file=config_file)
-    #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
-    db_dir = expand_path(getattr(config, 'manager_db_dir') or config.backup_dir)
-    backup_dir = config.backup_dir
-    backup_def = getattr(parsed_args, "backup_def", None)
-
-    # Match pattern for archive base names: e.g. test_FULL_2025-04-01
-    dar_pattern = re.compile(r"^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.1\.dar$")
-
-    # Step 1: scan backup_dir for .1.dar files
-    all_archives = set()
-    for fname in os.listdir(backup_dir):
-        match = dar_pattern.match(fname)
-        if match:
-            base = match.group(1)
-            if base.startswith(prefix):
-                if not backup_def or base.startswith(f"{backup_def}_"):
-                    all_archives.add(base)
-
-    # Step 2: exclude ones already present in the .db
-    db_path = os.path.join(db_dir, f"{backup_def}.db") if backup_def else None
-    existing = set()
-
-    if db_path and os.path.exists(db_path):
-        try:
-            result = subprocess.run(
-                ["dar_manager", "--base", db_path, "--list"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.DEVNULL,
-                text=True,
-                check=True
-            )
-            for line in result.stdout.splitlines():
-                parts = line.strip().split("\t")
-                if len(parts) >= 3:
-                    existing.add(parts[2].strip())
-        except subprocess.CalledProcessError:
-            pass
-
-    # Step 3: return filtered list
-    candidates = sorted(archive for archive in all_archives if archive not in existing)
-    return candidates or ["[no new archives]"]
+    try:
+        from dar_backup.config_settings import ConfigSettings
+        import subprocess
+        import re
+        import os
+        from datetime import datetime
+
+        config_file = get_config_file(parsed_args)
+        config = ConfigSettings(config_file=config_file)
+        #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
+        db_dir = expand_path(getattr(config, 'manager_db_dir') or config.backup_dir)
+        backup_dir = config.backup_dir
+        backup_def = getattr(parsed_args, "backup_def", None)
+
+        # Match pattern for archive base names: e.g. test_FULL_2025-04-01
+        dar_pattern = re.compile(r"^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.1\.dar$")
+
+        # Step 1: scan backup_dir for .1.dar files
+        all_archives = set()
+        for fname in os.listdir(backup_dir):
+            match = dar_pattern.match(fname)
+            if match:
+                base = match.group(1)
+                if base.startswith(prefix):
+                    if not backup_def or base.startswith(f"{backup_def}_"):
+                        all_archives.add(base)
+
+        # Step 2: exclude ones already present in the .db
+        db_path = os.path.join(db_dir, f"{backup_def}.db") if backup_def else None
+        existing = set()
+
+        if db_path and os.path.exists(db_path):
+            try:
+                result = subprocess.run(
+                    ["dar_manager", "--base", db_path, "--list"],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                    text=True,
+                    check=True
+                )
+                for line in result.stdout.splitlines():
+                    parts = line.strip().split("\t")
+                    if len(parts) >= 3:
+                        existing.add(parts[2].strip())
+            except subprocess.CalledProcessError:
+                pass
+
+        # Step 3: return filtered list
+        candidates = sorted(archive for archive in all_archives if archive not in existing)
+        return candidates or ["[no new archives]"]
+    except Exception:
+        completer_logger.exception("add_specific_archive_completer failed")
+        return []
 
 
 
@@ -735,8 +869,12 @@ def normalize_dir(path: str) -> str:
 
 # Reusable pattern for archive file naming
 archive_pattern = re.compile(
-    r'^.+?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2})\.\d+\.dar'
-    r'(?:\.vol\d+(?:\+\d+)?\.par2|\.par2)?$'
+    r'^.+?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2})'
+    r'(?:'
+    r'\.\d+\.dar(?:\.vol\d+(?:\+\d+)?\.par2|\.par2)?'
+    r'|(?:\.vol\d+(?:\+\d+)?\.par2|\.par2)'
+    r'|\.par2\.manifest\.ini'
+    r')$'
 )
 
 def is_safe_filename(filename: str) -> bool:
@@ -757,4 +895,119 @@ def is_safe_path(path: str) -> bool:
         and '..' not in normalized.split(os.sep)
     )
 
+def get_config_file(args) -> str:
+    """
+    Returns the config file path based on the following precedence:
+    1. Command-line argument (--config-file)
+    2. Environment variable (DAR_BACKUP_CONFIG_FILE)
+    3. Default path (~/.config/dar-backup/dar-backup.conf)
+    """
+    DEFAULT_CONFIG_FILE = "~/.config/dar-backup/dar-backup.conf"
+
+    env_cf = os.getenv("DAR_BACKUP_CONFIG_FILE")
+    env_cf = env_cf.strip() if env_cf else None
+
+    cli_cf = getattr(args, "config_file", None)
+    cli_cf = cli_cf.strip() if cli_cf else None
+    
+    raw_config = (
+        cli_cf
+        or env_cf
+        or DEFAULT_CONFIG_FILE
+    )
+
+    config_settings_path = os.path.abspath(os.path.expanduser(os.path.expandvars(raw_config)))
+    return config_settings_path
+
+
+
+def is_under_base_dir(candidate: Path, base_dir: Path) -> bool:
+    """
+    True iff candidate resolves under base_dir (symlink-safe).
+    """
+    try:
+        base = base_dir.resolve(strict=True)
+        resolved = candidate.resolve(strict=False)
+    except Exception:
+        return False
+    return resolved == base or base in resolved.parents
+
+
+def safe_remove_file(path_str: str, *, base_dir: Path) -> bool:
+    """
+    Remove a file only if it:
+      - is under base_dir (after resolve),
+      - matches archive naming convention by BASENAME,
+      - is a regular file (not a dir),
+      - is not a symlink (optional hardening).
+    Returns True if removed.
+    """
+    p = Path(path_str)
+
+    # Enforce containment first (defeats ../ and symlink escape)
+    if not is_under_base_dir(p, base_dir):
+        logger.warning("Refusing to delete outside base_dir: %s (base=%s)", p, base_dir)
+        return False
+
+    # Validate filename shape on basename only
+    if not is_safe_filename(p.name):
+        logger.warning("Refusing to delete non-matching filename: %s", p.name)
+        return False
+
+    # Hardening: don't follow symlinks
+    if p.is_symlink():
+        logger.warning("Refusing to delete symlink: %s", p)
+        return False
+
+    # Only delete regular files
+    if not p.is_file():
+        logger.warning("Refusing to delete non-file: %s", p)
+        return False
+
+    p.unlink()
+    return True
+
+
+
+# Allowed archive name:
+#   <definition>_(FULL|DIFF|INCR)_YYYY-MM-DD
+# Example:
+#   pj-homedir_INCR_2025-11-22
+_ARCHIVE_NAME_RE = re.compile(
+    r"^(?P<def>[A-Za-z0-9][A-Za-z0-9._-]{0,127})_"
+    r"(?P<kind>FULL|DIFF|INCR)_"
+    r"(?P<date>\d{4}-\d{2}-\d{2})$"
+)
+
+def is_archive_name_allowed(name: str) -> bool:
+    """
+    Return True iff the archive name is safe and valid.
+
+    Security properties:
+      - name only, never a path (no /, \\, or ..)
+      - strict allowed character set
+      - must be FULL / DIFF / INCR
+      - date must be a real calendar date
+    """
+    if not isinstance(name, str):
+        return False
+
+    name = name.strip()
+
+    # Reject anything path-like
+    if "/" in name or "\\" in name or ".." in name:
+        return False
+
+    m = _ARCHIVE_NAME_RE.match(name)
+    if not m:
+        return False
+
+    # Validate date is real (not just shape)
+    try:
+        date.fromisoformat(m.group("date"))   # <-- FIX
+        # alternatively:
+        # datetime.strptime(m.group("date"), "%Y-%m-%d")
+    except ValueError:
+        return False
 
+    return True