ddns 4.1.0b4__py2.py3-none-any.whl → 4.1.1__py2.py3-none-any.whl

ddns/scheduler/cron.py

@@ -0,0 +1,111 @@
+# -*- coding:utf-8 -*-
+"""
+Cron-based task scheduler for Unix-like systems
+@author: NewFuture
+"""
+
+import os
+import subprocess
+import tempfile
+
+from ..util.fileio import write_file
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+
+class CronScheduler(BaseScheduler):
+    """Cron-based task scheduler for Unix-like systems"""
+
+    SCHEDULER_NAME = "cron"
+
+    KEY = "# DDNS:"
+
+    def _update_crontab(self, lines):  # type: (list[str]) -> bool
+        """Update crontab with new content"""
+        try:
+            temp_path = tempfile.mktemp(suffix=".cron")
+            write_file(temp_path, u"\n".join(lines) + u"\n")  # fmt: skip
+            subprocess.check_call(["crontab", temp_path])
+            os.unlink(temp_path)
+            return True
+        except Exception as e:
+            self.logger.error("Failed to update crontab: %s", e)
+            return False
+
+    def is_installed(self, crontab_content=None):  # type: (str | None) -> bool
+        result = crontab_content or try_run(["crontab", "-l"], logger=self.logger) or ""
+        return self.KEY in result
+
+    def get_status(self):
+        status = {"scheduler": "cron", "installed": False}  # type: dict[str, str | bool | int | None]
+        # Get crontab content once and reuse it for all checks
+        crontab_content = try_run(["crontab", "-l"], logger=self.logger) or ""
+        lines = crontab_content.splitlines()
+        line = next((i for i in lines if self.KEY in i), "").strip()
+
+        if line:  # Task is installed
+            status["installed"] = True
+            status["enabled"] = bool(line and not line.startswith("#"))
+        else:  # Task not installed
+            status["enabled"] = False
+
+        cmd_groups = line.split(self.KEY, 1) if line else ["", ""]
+        parts = cmd_groups[0].strip(" #\t").split() if cmd_groups[0] else []
+        status["interval"] = int(parts[0][2:]) if len(parts) >= 5 and parts[0].startswith("*/") else None
+        status["command"] = " ".join(parts[5:]) if len(parts) >= 6 else None
+        status["description"] = cmd_groups[1].strip() if len(cmd_groups) > 1 else None
+
+        return status
+
+    def install(self, interval, ddns_args=None):
+        ddns_commands = self._build_ddns_command(ddns_args)
+        # Convert array to properly quoted command string for cron
+        ddns_command = self._quote_command_array(ddns_commands)
+        description = self._get_description()
+        cron_entry = '*/{} * * * * cd "{}" && {} # DDNS: {}'.format(interval, os.getcwd(), ddns_command, description)
+
+        crontext = try_run(["crontab", "-l"], logger=self.logger) or ""
+        lines = [line for line in crontext.splitlines() if self.KEY not in line]
+        lines.append(cron_entry)
+
+        if self._update_crontab(lines):
+            return True
+        else:
+            self.logger.error("Failed to install DDNS cron job")
+            return False
+
+    def uninstall(self):
+        return self._modify_cron_lines("uninstall")
+
+    def enable(self):
+        return self._modify_cron_lines("enable")
+
+    def disable(self):
+        return self._modify_cron_lines("disable")
+
+    def _modify_cron_lines(self, action):  # type: (str) -> bool
+        """Helper to enable, disable, or uninstall cron lines"""
+        crontext = try_run(["crontab", "-l"], logger=self.logger)
+        if not crontext or self.KEY not in crontext:
+            self.logger.info("No crontab found")
+            return False
+
+        modified_lines = []
+        for line in crontext.rstrip("\n").splitlines():
+            if self.KEY not in line:
+                modified_lines.append(line)
+            elif action == "uninstall":
+                continue  # Skip DDNS lines (remove them)
+            elif action == "enable" and line.strip().startswith("#"):
+                uncommented = line.lstrip(" #\t").lstrip()  # Enable: uncomment the line
+                modified_lines.append(uncommented if uncommented else line)
+            elif action == "disable" and not line.strip().startswith("#"):
+                modified_lines.append("# " + line)  # Disable: comment the line
+            else:
+                raise ValueError("Invalid action: {}".format(action))
+
+        if self._update_crontab(modified_lines):
+            return True
+        else:
+            self.logger.error("Failed to %s DDNS cron job", action)
+            return False

ddns/scheduler/launchd.py

@@ -0,0 +1,130 @@
+# -*- coding:utf-8 -*-
+"""
+macOS launchd-based task scheduler
+@author: NewFuture
+"""
+
+import os
+import re
+
+from ..util.fileio import read_file_safely, write_file
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+
+class LaunchdScheduler(BaseScheduler):
+    """macOS launchd-based task scheduler"""
+
+    LABEL = "cc.newfuture.ddns"
+
+    def _get_plist_path(self):
+        return os.path.expanduser("~/Library/LaunchAgents/{}.plist".format(self.LABEL))
+
+    def is_installed(self):
+        return os.path.exists(self._get_plist_path())
+
+    def get_status(self):
+        # Read plist content once and use it to determine installation status
+        content = read_file_safely(self._get_plist_path())
+        status = {"scheduler": "launchd", "installed": bool(content)}
+        if not content:
+            return status
+
+        # For launchd, check if service is actually loaded/enabled
+        result = try_run(["launchctl", "list"], logger=self.logger)
+        status["enabled"] = bool(result) and self.LABEL in result
+
+        # Get interval
+        interval_match = re.search(r"<key>StartInterval</key>\s*<integer>(\d+)</integer>", content)
+        status["interval"] = int(interval_match.group(1)) // 60 if interval_match else None
+
+        # Get command
+        program_match = re.search(r"<key>Program</key>\s*<string>([^<]+)</string>", content)
+        if program_match:
+            status["command"] = program_match.group(1)
+        else:
+            args_section = re.search(r"<key>ProgramArguments</key>\s*<array>(.*?)</array>", content, re.DOTALL)
+            if args_section:
+                strings = re.findall(r"<string>([^<]+)</string>", args_section.group(1))
+                if strings:
+                    status["command"] = " ".join(strings)
+
+        # Get comments
+        desc_match = re.search(r"<key>Description</key>\s*<string>([^<]+)</string>", content)
+        status["description"] = desc_match.group(1) if desc_match else None
+
+        return status
+
+    def install(self, interval, ddns_args=None):
+        plist_path = self._get_plist_path()
+        program_args = self._build_ddns_command(ddns_args)
+
+        # Create comment with version and install date (consistent with Windows)
+        comment = self._get_description()
+
+        # Generate plist XML using template string for proper macOS plist format
+        program_args_xml = "".join("        <string>{}</string>\n".format(arg) for arg in program_args)
+
+        plist_content = """<?xml version="1.0" encoding="UTF-8"?>
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>{label}</string>
+    <key>Description</key>
+    <string>{description}</string>
+    <key>ProgramArguments</key>
+    <array>{program}</array>
+    <key>StartInterval</key>
+    <integer>{interval}</integer>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>WorkingDirectory</key>
+    <string>{dir}</string>
+</dict>
+</plist>""".format(
+            label=self.LABEL, description=comment, program=program_args_xml, interval=interval * 60, dir=os.getcwd()
+        )
+
+        write_file(plist_path, plist_content)
+        result = try_run(["launchctl", "load", plist_path], logger=self.logger)
+        if result is not None:
+            self.logger.info("DDNS launchd service installed successfully")
+            return True
+        else:
+            self.logger.error("Failed to load launchd service")
+            return False
+
+    def uninstall(self):
+        plist_path = self._get_plist_path()
+        try_run(["launchctl", "unload", plist_path], logger=self.logger)  # Ignore errors
+        try:
+            os.remove(plist_path)
+        except OSError:
+            pass
+
+        self.logger.info("DDNS launchd service uninstalled successfully")
+        return True
+
+    def enable(self):
+        plist_path = self._get_plist_path()
+        if not os.path.exists(plist_path):
+            self.logger.error("DDNS launchd service not found")
+            return False
+
+        result = try_run(["launchctl", "load", plist_path], logger=self.logger)
+        if result is not None:
+            self.logger.info("DDNS launchd service enabled successfully")
+            return True
+        else:
+            self.logger.error("Failed to enable launchd service")
+            return False
+
+    def disable(self):
+        plist_path = self._get_plist_path()
+        result = try_run(["launchctl", "unload", plist_path], logger=self.logger)
+        if result is not None:
+            self.logger.info("DDNS launchd service disabled successfully")
+            return True
+        else:
+            self.logger.error("Failed to disable launchd service")
+            return False

ddns/scheduler/schtasks.py

@@ -0,0 +1,120 @@
+# -*- coding:utf-8 -*-
+"""
+schtasks-based task scheduler
+@author: NewFuture
+"""
+
+import os
+import re
+import tempfile
+
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+
+class SchtasksScheduler(BaseScheduler):
+    """schtasks-based task scheduler"""
+
+    NAME = "DDNS"
+
+    def _schtasks(self, *args):
+        """Helper to run schtasks commands with consistent error handling"""
+        result = try_run(["schtasks"] + list(args), logger=self.logger)
+        return result is not None
+
+    def _extract_xml(self, xml_text, tag_name):
+        """Extract XML tag content using regex for better performance and flexibility"""
+        pattern = r"<{0}[^>]*>(.*?)</{0}>".format(re.escape(tag_name))
+        match = re.search(pattern, xml_text, re.DOTALL)
+        return match.group(1).strip() if match else None
+
+    def is_installed(self):
+        result = try_run(["schtasks", "/query", "/tn", self.NAME], logger=self.logger) or ""
+        return self.NAME in result
+
+    def get_status(self):
+        # Use XML format for language-independent parsing
+        task_xml = try_run(["schtasks", "/query", "/tn", self.NAME, "/xml"], logger=self.logger)
+        status = {"scheduler": "schtasks", "installed": bool(task_xml)}
+
+        if not task_xml:
+            return status  # Task not installed, return minimal status
+
+        status["enabled"] = self._extract_xml(task_xml, "Enabled") != "false"
+        command = self._extract_xml(task_xml, "Command")
+        arguments = self._extract_xml(task_xml, "Arguments")
+        status["command"] = "{} {}".format(command, arguments) if command and arguments else command
+
+        # Parse interval: PT10M -> 10, fallback to original string
+        interval_str = self._extract_xml(task_xml, "Interval")
+        interval_match = re.search(r"PT(\d+)M", interval_str) if interval_str else None
+        status["interval"] = int(interval_match.group(1)) if interval_match else interval_str
+
+        # Show description if exists, otherwise show installation date
+        description = self._extract_xml(task_xml, "Description") or self._extract_xml(task_xml, "Date")
+        if description:
+            status["description"] = description
+        return status
+
+    def install(self, interval, ddns_args=None):
+        # Build command line as array: prefer pythonw for script mode, or compiled exe directly
+        cmd_array = self._build_ddns_command(ddns_args)
+        workdir = os.getcwd()
+
+        # Split array into executable and arguments for schtasks XML format
+        # For Windows scheduler, prefer pythonw.exe to avoid console window
+        executable = cmd_array[0].replace("python.exe", "pythonw.exe")
+        arguments = self._quote_command_array(cmd_array[1:]) if len(cmd_array) > 1 else ""
+
+        # Create XML task definition with working directory support
+        description = self._get_description()
+
+        # Use template string to generate Windows Task Scheduler XML
+        xml_content = """<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>{description}</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <TimeTrigger>
+      <StartBoundary>1900-01-01T00:00:00</StartBoundary>
+      <Repetition>
+        <Interval>PT{interval}M</Interval>
+      </Repetition>
+      <Enabled>true</Enabled>
+    </TimeTrigger>
+  </Triggers>
+  <Actions>
+    <Exec>
+      <Command>{exe}</Command>
+      <Arguments>{arguments}</Arguments>
+      <WorkingDirectory>{dir}</WorkingDirectory>
+    </Exec>
+  </Actions>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+  </Settings>
+</Task>""".format(description=description, interval=interval, exe=executable, arguments=arguments, dir=workdir)
+
+        # Write XML to temp file and use it to create task
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".xml", delete=False) as f:
+            f.write(xml_content)
+            xml_file = f.name
+
+        try:
+            success = self._schtasks("/Create", "/XML", xml_file, "/TN", self.NAME, "/F")
+            return success
+        finally:
+            os.unlink(xml_file)
+
+    def uninstall(self):
+        success = self._schtasks("/Delete", "/TN", self.NAME, "/F")
+        return success
+
+    def enable(self):
+        return self._schtasks("/Change", "/TN", self.NAME, "/Enable")
+
+    def disable(self):
+        return self._schtasks("/Change", "/TN", self.NAME, "/Disable")

ddns/scheduler/systemd.py

@@ -0,0 +1,139 @@
+# -*- coding:utf-8 -*-
+"""
+Systemd timer-based task scheduler for Linux
+@author: NewFuture
+"""
+
+import os
+import re
+
+from ..util.fileio import read_file_safely, write_file
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+try:  # python 3
+    PermissionError  # type: ignore
+except NameError:  # python 2 doesn't have PermissionError, use OSError instead
+    PermissionError = IOError
+
+
+class SystemdScheduler(BaseScheduler):
+    """Systemd timer-based task scheduler for Linux"""
+
+    SERVICE_NAME = "ddns.service"
+    TIMER_NAME = "ddns.timer"
+    SERVICE_PATH = "/etc/systemd/system/ddns.service"
+    TIMER_PATH = "/etc/systemd/system/ddns.timer"
+
+    def _systemctl(self, *args):
+        """Run systemctl command and return success status"""
+        result = try_run(["systemctl"] + list(args), logger=self.logger)
+        return result is not None
+
+    def is_installed(self):
+        """Check if systemd timer files exist"""
+        return os.path.exists(self.SERVICE_PATH) and os.path.exists(self.TIMER_PATH)
+
+    def get_status(self):
+        """Get comprehensive status information"""
+        installed = self.is_installed()
+        status = {"scheduler": "systemd", "installed": installed}
+        if not installed:
+            return status
+
+        # Check if timer is enabled
+        result = try_run(["systemctl", "is-enabled", self.TIMER_NAME], logger=self.logger)
+        status["enabled"] = bool(result and result.strip() == "enabled")
+
+        # Extract interval from timer file
+        timer_content = read_file_safely(self.TIMER_PATH) or ""
+        match = re.search(r"OnUnitActiveSec=(\d+)m", timer_content)
+        status["interval"] = int(match.group(1)) if match else None
+
+        # Extract command and description from service file
+        service_content = read_file_safely(self.SERVICE_PATH) or ""
+        match = re.search(r"ExecStart=(.+)", service_content)
+        status["command"] = match.group(1).strip() if match else None
+        desc_match = re.search(r"Description=(.+)", service_content)
+        status["description"] = desc_match.group(1).strip() if desc_match else None
+
+        return status
+
+    def install(self, interval, ddns_args=None):
+        """Install systemd timer with specified interval"""
+        ddns_commands = self._build_ddns_command(ddns_args)
+        # Convert array to properly quoted command string for ExecStart
+        ddns_command = self._quote_command_array(ddns_commands)
+        work_dir = os.getcwd()
+        description = self._get_description()
+
+        # Create service file content
+        service_content = u"""[Unit]
+Description={}
+After=network.target
+
+[Service]
+Type=oneshot
+WorkingDirectory={}
+ExecStart={}
+""".format(description, work_dir, ddns_command)  # fmt: skip
+
+        # Create timer file content
+        timer_content = u"""[Unit]
+Description=DDNS automatic IP update timer
+Requires={}
+
+[Timer]
+OnUnitActiveSec={}m
+Unit={}
+
+[Install]
+WantedBy=multi-user.target
+""".format(self.SERVICE_NAME, interval, self.SERVICE_NAME)  # fmt: skip
+
+        try:
+            # Write service and timer files
+            write_file(self.SERVICE_PATH, service_content)
+            write_file(self.TIMER_PATH, timer_content)
+        except PermissionError as e:
+            self.logger.debug("Permission denied when writing systemd files: %s", e)
+            print("Permission denied. Please run as root or use sudo.")
+            print("or use cron scheduler (with --scheduler=cron) instead.")
+            return False
+        except Exception as e:
+            self.logger.error("Failed to write systemd files: %s", e)
+            return False
+
+        if self._systemctl("daemon-reload") and self._systemctl("enable", self.TIMER_NAME):
+            self._systemctl("start", self.TIMER_NAME)
+            return True
+        else:
+            self.logger.error("Failed to enable/start systemd timer")
+            return False
+
+    def uninstall(self):
+        """Uninstall systemd timer and service"""
+        self.disable()  # Stop and disable timer
+        # Remove systemd files
+        try:
+            os.remove(self.SERVICE_PATH)
+            os.remove(self.TIMER_PATH)
+            self._systemctl("daemon-reload")  # Reload systemd configuration
+            return True
+
+        except PermissionError as e:
+            self.logger.debug("Permission denied when removing systemd files: %s", e)
+            print("Permission denied. Please run as root or use sudo.")
+            return False
+        except Exception as e:
+            self.logger.error("Failed to remove systemd files: %s", e)
+            return False
+
+    def enable(self):
+        """Enable and start systemd timer"""
+        return self._systemctl("enable", self.TIMER_NAME) and self._systemctl("start", self.TIMER_NAME)
+
+    def disable(self):
+        """Disable and stop systemd timer"""
+        self._systemctl("stop", self.TIMER_NAME)
+        return self._systemctl("disable", self.TIMER_NAME)

{ddns-4.1.0b4.dist-info → ddns-4.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddns
-Version: 4.1.0b4
+Version: 4.1.1
 Summary: Dynamic DNS client for multiple providers, supporting IPv4 and IPv6.
 Author-email: NewFuture <python@newfuture.cc>
 License-Expression: MIT

{ddns-4.1.0b4.dist-info → ddns-4.1.1.dist-info}/RECORD

@@ -1,15 +1,20 @@
 ddns/__builtins__.pyi,sha256=9ZCOh51Aq6nBUZTt_0TBKpzcUeTxi-KBw-9TkXIGSH4,128
-ddns/__init__.py,sha256=KJr4XPaFaRCOLq4Fwvs0mOh6lIRhExsFH6w4ms402u8,258
-ddns/__main__.py,sha256=VgANBMJ01nI5-nRYyKkIcLG0GOO_AKjHRdqVV0cwLrk,5366
+ddns/__init__.py,sha256=t_uBV-9inA0NtqwVSHDiz-m-g1jrsaxmLtM31mTnFYs,256
+ddns/__main__.py,sha256=gZjSw-FUxr4Z8l0h0hPpdp2B46ANiCtyAXAtL1myVa0,5423
 ddns/cache.py,sha256=A1s3rnOJbPrGEjbGbbISrVg46lZFzZ84WPdzHaCtYBk,5971
 ddns/ip.py,sha256=6H5jYv-TT-o0wSoFAGOlTAbf-TAS92Kx6vafi3LXTA4,5151
+ddns/config/__init__.py,sha256=p8AoT2ZJ4LXAf0ij3i2zq4sq2rbIkv70lf_NQQVugKM,6871
+ddns/config/cli.py,sha256=LcNXWTYimCCHm0kUVAb6ERdJVq9SsadEZyRiPSlT2PU,14447
+ddns/config/config.py,sha256=Qhlz3UNcyQ8Evcp4T3xvM54LvMMD-wSEI4Xq3YgtGpY,7234
+ddns/config/env.py,sha256=RSf4XfMN50zCJQ7QxLQE_4gQdNCiD-z3Gu8UCZHfqPM,2503
+ddns/config/file.py,sha256=TzSU2qIgHKeJetkfM7doQVS16TfPcnD4ji-wOnp8ZRo,6450
 ddns/provider/__init__.py,sha256=qAw-R-l7nUA9L96Tmr2n-T7_g8T9Mah7u615yg2zScY,2793
 ddns/provider/_base.py,sha256=q31rqiiqEmM5Kt7SLdRjcREDrlGdRAQX6mNoe8ULPz8,20065
 ddns/provider/_signature.py,sha256=fF8XxMDkXjia96d1gIVYWc72MVVe65AAnD7qr51qKXA,4140
 ddns/provider/alidns.py,sha256=zymb1lNaj8yfUaQr8xfSxKojsLPfbo5orZcxBigcblM,6123
 ddns/provider/aliesa.py,sha256=-4pBmV03NWot5CVMQYluDHChk-nwb1kQpmUdlZSLy6A,4722
 ddns/provider/callback.py,sha256=QAOSWr-LWN8UG3NIEMWTvjax1g9R0rCJz6Xtr4KbQDo,2925
-ddns/provider/cloudflare.py,sha256=BGV_73QqKYyOWkG5ijphrsZJx2C8Y_fdo0NElwFVx9c,4497
+ddns/provider/cloudflare.py,sha256=_O_0H3mEehue8fBqQIhP_3hga71lb4or7SBQaezUMLE,5532
 ddns/provider/debug.py,sha256=JKneEkOMasYxis9kcU97mHJMo3jdLRuU1w7AAdAqMhY,586
 ddns/provider/dnscom.py,sha256=4r2ijL158dnSojj2WuLRWyxvUtGvibuowHvDzUdV-QU,3681
 ddns/provider/dnspod.py,sha256=kgFsTULdooPDd6LmNt2cmLJjw8JRsmq8sfMpTs8REPc,4423
@@ -20,14 +25,20 @@ ddns/provider/huaweidns.py,sha256=upKKfBXYhQIzqxuoSRQYBXCx4lpHVjHJJQL0BS8rFsE,56
 ddns/provider/namesilo.py,sha256=jgqkQUcHVCyVjYoxazmcN9Gu_Zd-EAv3aSnNmHHJ1jk,5843
 ddns/provider/noip.py,sha256=RivoLhWJJJuiBzEbtRnnHiBkcLfbvAGglZKKY9s_lcY,4035
 ddns/provider/tencentcloud.py,sha256=aEWqQ00EWUG-JWW2D0IuJDWZ1OdbTPheGeYSlIh7bqQ,7159
+ddns/scheduler/__init__.py,sha256=yBoxs0cnCVdGKk4T5m1tZe75do-iH2806bq8ZHW-dG4,2454
+ddns/scheduler/_base.py,sha256=PSWiDQ3FCb5eFT4ZO9zuPu2ADKswlLwhrpgc2AVLEoY,2813
+ddns/scheduler/cron.py,sha256=X317yye2Kg_Ow9W1OOaPBipRmJTBZYetyM9CaqPkW6I,4372
+ddns/scheduler/launchd.py,sha256=HP7G6K9CGtsqWcSGl25NFKquSv9Ak0oDEhxBSmyOr5Y,4648
+ddns/scheduler/schtasks.py,sha256=P5APkh6eWwZh8AedYNq4HQWFajleTo-nezcZxP_NyLI,4608
+ddns/scheduler/systemd.py,sha256=m3P_TJYMSgZZH_CndrfKVu0B3o7lXZw7D9oA5c2yguc,4960
 ddns/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ddns/util/comment.py,sha256=_B8sRpCJksNspsdld4ha03W1TAi-MyPRK7pL7ym0j9k,2199
 ddns/util/fileio.py,sha256=bykJgmdy3gZ79iUQSVpMprRej1PGMJSDSHedIngFdG4,3169
 ddns/util/http.py,sha256=qxfvpN0xt7GZ-GsHFhij4yjH0frWAC52XfaX5ZigFMw,12942
 ddns/util/try_run.py,sha256=juDPxvT5xUabK2DiQNtFIyaATehtserHCVkP7_joSyU,1304
-ddns-4.1.0b4.dist-info/licenses/LICENSE,sha256=MI-ECjp-Vl7WZLiSPY6r5VwrOReNiICVB1QCXiUGt_s,1111
-ddns-4.1.0b4.dist-info/METADATA,sha256=CtRAgOz4l9v8t-l5QxIgBWV2tF2jGtglSfeEbbOC4yg,19636
-ddns-4.1.0b4.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-ddns-4.1.0b4.dist-info/entry_points.txt,sha256=2-VbA-WZcjebkZrGKvUCuBBRYF4xQNMoLIoGaS234WU,44
-ddns-4.1.0b4.dist-info/top_level.txt,sha256=Se0wn3T8Bc4pj55dGwVrCe8BFwmFCBwQVHF1bTyV0o0,5
-ddns-4.1.0b4.dist-info/RECORD,,
+ddns-4.1.1.dist-info/licenses/LICENSE,sha256=MI-ECjp-Vl7WZLiSPY6r5VwrOReNiICVB1QCXiUGt_s,1111
+ddns-4.1.1.dist-info/METADATA,sha256=eC7krFPlc8yBCUD_Z741HQZ7e5YavCz3r-Iapgx7oiw,19634
+ddns-4.1.1.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+ddns-4.1.1.dist-info/entry_points.txt,sha256=2-VbA-WZcjebkZrGKvUCuBBRYF4xQNMoLIoGaS234WU,44
+ddns-4.1.1.dist-info/top_level.txt,sha256=Se0wn3T8Bc4pj55dGwVrCe8BFwmFCBwQVHF1bTyV0o0,5
+ddns-4.1.1.dist-info/RECORD,,