i3-notifier 0.19__py3-none-any.whl

i3_notifier-0.19.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: i3-notifier
+Version: 0.19
+Summary: A notification daemon for i3
+Author: Sencer Selcuk
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: dbus-python==1.2.16
+Requires-Dist: i3ipc
+Requires-Dist: python-daemon==2.2.4
+Requires-Dist: pyxdg==0.26
+Description-Content-Type: text/markdown
+
+# i3 Notification Manager (Requires a recent version of rofi)
+
+This is a notification manager for i3 desktop environment inspired by 
+[Rofication](https://github.com/DaveDavenport/Rofication). Like 
+Rofication, it implements the [Gnome Desktop Notifications 
+Standard](https://developer.gnome.org/notification-spec/) standard. 
+
+Also see the companion py3status module 
+[py3-notifier](https://github.com/sencer/py3-notifier).
+
+## Differences from Rofication
+
+- Notifications are stored in a tree structure, where they can be grouped 
+  by, for example, the application that is sending the notification and 
+  the subject. This is highly configurable. (No docs at the moment, but 
+  see the `examples/i3_notifier_config.py`; also see the comments in 
+  `i3notifier/config.py`)
+- Allows bulk deletion of notifications in a category.
+- Implements "default" action.
+- Shows icons.
+- Does not use sockets, rather adds new dbus methods to show the 
+  notifications and get the count of notifications.
+- Code is modular, should be straight forward to use another GUI rather 
+  than Rofi; or another data structure rather than tree structure.
+
+## What does it look like?
+
+![animation](/images/widget.gif)
+
+## Usage
+
+To install (also see the requirements.txt)
+
+    pip install i3-notifier
+    
+Make sure you are not running any other notification daemon (if you are running `dunst` for example, kill it with `killall dunst`). Then start `i3-notifier`. You might want to make sure `i3-notifier` and its companion script `switch-to-urgent.py` are in the `$PATH`. You can confirm it is running by
+
+    dbus-send --session --print-reply --dest=org.freedesktop.Notifications /org/freedesktop/Notifications org.freedesktop.Notifications.GetServerInformation
+
+Then to launch GUI; bind this to a shortcut
+
+    dbus-send --session --print-reply --dest=org.freedesktop.Notifications /org/freedesktop/Notifications org.freedesktop.Notifications.ShowNotifications
+
+## Keybindings
+|                  Key                        |               Action                |
+|--------------------------------------------:|-------------------------------------|
+`j`, `Down`, `Tab` or `Ctrl-N`                | Choose next
+`k`, `Up` or `Ctrl-P`                         | Choose previous
+`Enter`, `Space` or `Left Click`              | Expand if group; execute action if singleton
+`Shift-Enter`                                 | Execute action
+`Esc`, `Ctrl+[` or `Backspace`                | One level up or exit from top level
+`` ` ``, `Ctrl+Backspace` or `Shift-Backspace`| Exit from any level.
+`Delete`                                      | Delete notification or group
+`Ctrl+Delete`, `Shift+Delete`                 | Delete single notification
+
+To get notification count & urgency
+
+    dbus-send --session --print-reply=literal --dest=org.freedesktop.Notifications /org/freedesktop/Notifications org.freedesktop.Notifications.ShowNotificationCount
+
+One can use this with i3blocks to show notifications in the bar
+or even better switch to py3status and install 
+[py3-notifier](https://github.com/sencer/py3-notifier).
+
+    command = "(dbus-send --session --print-reply=literal --dest=org.freedesktop.Notifications /org/freedesktop/Notifications org.freedesktop.Notifications.ShowNotificationCount 2>/dev/null || ($HOME/.local/bin/i3-notifier && echo '? ? ?'))|tr -s ' '|cut -d' ' -f 3"

i3_notifier-0.19.dist-info/RECORD

@@ -0,0 +1,17 @@
+i3notifier/config.py,sha256=f6LaWFxw0kfss2P8rBdfMl-jpVBNgNR-pkUXm70XszM,1942
+i3notifier/data_manager.py,sha256=2olnf5nCkl5fS0OEryGQNzrNBjdIs6Lfgq_NhJx6pzw,4497
+i3notifier/main.py,sha256=5-Ph7aR4Gb3hJYKL2tOrFuPMRxc-zpGyjkHFPqyYpKc,5178
+i3notifier/notification.py,sha256=F5ly4EiikEVMmKRttTiMUsxS8DlB91OySsaSRMtsY0U,4589
+i3notifier/notification_fetcher.py,sha256=ew1nIS5MKMvLmGzLDko1_B5M4MHZVG7pyy0ewy0rwl4,9540
+i3notifier/rofi_gui.py,sha256=UIEYbkC_U5d721PN6BbNct_inEn7Eh6QDVbMFEaGJOI,1814
+i3notifier/switch_to_urgent.py,sha256=yaduAqeRi71nTn05YVDxUEw-MoJAi329LZCJutG40Ps,329
+i3notifier/user_config.py,sha256=-n9EibzE8Zf5q78WlvvLdCITPKCxOQh0iq7bljXxZko,1354
+i3notifier/utils.py,sha256=PRMy_tjpoWcoX7S7cflAma4Li0hzNa3MFXGzmtjpuo0,1135
+i3notifier/rofi-theme/common.rasi,sha256=Wr-F3pMUOikNwrSyCXT1aZR-aHlI5TzHLOLzYKN-KrQ,1643
+i3notifier/rofi-theme/sidebar.rasi,sha256=DZOBBuBH04C49c5vySvd6OEPHGvtkCtdWaVqlpY17Ro,153
+i3notifier/rofi-theme/widget.rasi,sha256=g8B5Agx8m4BLe3H-u-misuEfcvMdKBhGeFFss3Miwmc,112
+i3_notifier-0.19.dist-info/METADATA,sha256=46UmTzLIGeCfBI-LBpqeT9T92J4tekzu903mUtIfXC4,3677
+i3_notifier-0.19.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+i3_notifier-0.19.dist-info/entry_points.txt,sha256=xDkkzgLegL1HTc8OPLWIjUsLS11bPHZFagRVXCJGVLk,105
+i3_notifier-0.19.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+i3_notifier-0.19.dist-info/RECORD,,

i3_notifier-0.19.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

i3_notifier-0.19.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+i3-notifier = i3notifier.main:main
+switch-to-urgent = i3notifier.switch_to_urgent:main

i3_notifier-0.19.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

i3notifier/config.py

@@ -0,0 +1,58 @@
+from datetime import datetime
+
+from .utils import strip_tags, strip_tags_and_escape
+
+
+class Config:
+    pre_close_hooks = []
+    post_close_hooks = []
+    pre_action_hooks = []
+    post_action_hooks = []
+
+    # Ignore expiration by default.
+    expires = False
+
+    def should_apply(notification):
+        # To group notifications and apply certain formatting inherit this
+        # class and make sure should_apply(notification) is the first Config
+        # that returns True to those notifications.
+        return True
+
+    def get_keys(notification):
+        # Returns a tuple, each element of which corresponds to the group
+        # name that the notification should be assigned at the
+        # corresponding nesting level.
+        return (notification.app_name or "_", notification.body)
+
+    def update_notification(notification):
+        # Edit the notification before saving it. By default no edits are
+        # made.
+        return notification
+
+    def format_notification(notification):
+        time = datetime.fromtimestamp(notification.created_at // 1e9).strftime("%H:%M")
+        # Format the notification
+        text = f"<b>{strip_tags_and_escape(notification.summary)}</b> "
+        text += f"<small>{time}</small>"
+        text += f"<small> {strip_tags_and_escape(notification.app_name)}</small>"
+
+        if notification.body:
+            text += (
+                "\n<i>"
+                + strip_tags_and_escape(notification.body.replace("\n", "").strip())
+                + "</i>"
+            )
+
+        if notification.app_icon:
+            return (
+                text.encode("utf-8")
+                + b"\x00icon\x1f"
+                + notification.app_icon.encode("utf-8")
+            )
+        else:
+            return text.encode("utf-8")
+
+    def single_line(notification):
+        return f"{strip_tags(notification.summary)} : {strip_tags(notification.body)}".replace(
+            "\n", ""
+        ).strip()

i3notifier/data_manager.py

@@ -0,0 +1,144 @@
+import pickle
+import threading
+
+from .notification import Notification, NotificationCluster
+
+
+class DataManager(threading.Thread):
+
+    __slots__ = "tree", "map", "lock", "configs", "dump_path", "last"
+
+    def __init__(self, configs, dump_path):
+        super().__init__()
+
+        self.tree = NotificationCluster()
+        self.map = dict()
+        self.last = None
+
+        self.lock = threading.Lock()
+        self.configs = configs
+        self.dump_path = dump_path
+
+        try:
+            for notification in pickle.load(open(dump_path, "rb")):
+                self.add_notification(notification)
+        except:
+            pass
+
+    def _recursive_add_notification(cluster, notification, keys, i=0):
+        if i == len(keys):
+            return
+
+        if keys[i] not in cluster.notifications:
+            cluster.notifications[keys[i]] = NotificationCluster()
+
+        DataManager._recursive_add_notification(
+            cluster.notifications[keys[i]], notification, keys, i + 1
+        )
+        cluster.add(keys[i], notification)
+
+    def add_notification(self, notification):
+        for config in self.configs:
+            if config.should_apply(notification):
+                config.update_notification(notification)
+                notification.config = config
+                break
+
+        keys = notification.keys()
+
+        if notification.id in self.map:
+            self.remove_notification(notification.id)
+
+        with self.lock:
+            self.last = notification
+            self.map[notification.id] = keys
+            DataManager._recursive_add_notification(
+                self.tree, notification, [*keys, notification.id]
+            )
+
+    def _recursive_remove_notification(cluster, keys, i=0):
+        key = keys[i]
+        best_key = i == len(keys) - 1
+        has_key = key in cluster.notifications
+        if best_key and not has_key:
+            # Short-cutted view, descend
+            key = list(cluster.notifications.keys())[0]
+            i -= 1
+
+        stop_case = best_key and has_key
+        if stop_case:
+            cluster_to_delete = cluster.notifications[key]
+            best = cluster_to_delete.best
+            urgency = cluster.urgency
+            nremoved = len(cluster_to_delete)
+        else:
+            nremoved, best, urgency = DataManager._recursive_remove_notification(
+                cluster.notifications[key], keys, i + 1
+            )
+
+        if len(cluster.notifications[key]) == 0 or stop_case:
+            del cluster.notifications[key]
+
+        cluster._len -= nremoved
+
+        if best is cluster._best:
+            cluster._best = None
+
+        if urgency == cluster._urgency:
+            cluster._urgency = None
+
+        return nremoved, best, urgency
+
+    def remove_notification(self, id, context=()):
+        with self.lock:
+            if isinstance(id, int):
+                if self.last and id == self.last.id:
+                    self.last = None
+
+                context = self.map.pop(id)
+                notification = self.get_context(context).notifications[id]
+                if notification.timer is not None:
+                    notification.timer.cancel()
+            else:
+                for leaf in self.get_context(context).notifications[id].leafs():
+                    if self.last and leaf.id == self.last.id:
+                        self.last = None
+                    if leaf.timer is not None:
+                        leaf.timer.cancel()
+                    self.map.pop(leaf.id)
+
+            DataManager._recursive_remove_notification(self.tree, [*context, id], i=0)
+
+    def get_context_by_id(self, id):
+        return self.get_context(self.map[id])
+
+    def get_context(self, context=()):
+        p = self.tree
+
+        if context and context[0] not in p.notifications:
+            while len(p.notifications) == 1:
+                p = next(iter(p.notifications.values()))
+
+        for key in context:
+            p = p.notifications[key]
+
+        while len(p.notifications) == 1:
+            child = next(iter(p.notifications.values()))
+
+            if isinstance(child, Notification):
+                break
+
+            p = child
+
+        return p
+
+    def dump(self):
+        pickle.dump(
+            [notification.strip() for notification in self.tree.leafs()],
+            open(self.dump_path, "wb"),
+        )
+
+    def cancel_timers(self):
+        for notification in self.tree.leafs():
+            if notification.timer is not None:
+                notification.timer.cancel()

i3notifier/main.py

@@ -0,0 +1,170 @@
+import argparse
+import dbus
+import logging
+import logging.handlers
+import os
+import signal
+import sys
+
+import dbus.mainloop.glib
+
+import daemon
+import daemon.pidfile
+from gi.repository import GLib
+from i3notifier.data_manager import DataManager
+from i3notifier.notification_fetcher import NotificationFetcher
+from i3notifier.rofi_gui import RofiGUI
+from i3notifier.user_config import get_user_config
+
+logger = logging.getLogger("i3notifier")
+files_preserve = []
+
+
+def run_daemon(config_path=None, nodaemon=False):
+    try:
+        userconfig = get_user_config(config_path)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    logger.info(f"Found {len(userconfig.config_list)} configurations.")
+
+    dump_path = "/tmp/i3-notifier.dump"
+    logger.info(
+        f"Notifications will be dumped to {dump_path} on graceful exit or when asked."
+    )
+    data_manager = DataManager(userconfig.config_list, dump_path)
+
+    gui = RofiGUI(theme=userconfig.theme)
+
+    def dump_and_exit(n, f):
+        data_manager.dump()
+        data_manager.cancel_timers()
+        sys.exit(0)
+
+    pid_file = "/tmp/i3-notifier.pid"
+
+    if os.path.exists(pid_file):
+        try:
+            pid = int(open(pid_file).read().strip())
+            os.kill(pid, 0)
+            logger.info(f"i3-notifier is already running with pid {pid}.")
+        except:
+            os.remove(pid_file)
+            logger.info(
+                "i3-notifier is not running, but a lock file exists. Cleaning up."
+            )
+
+    def run():
+        logger.info(f"Creating lock file {pid_file}")
+        with open(pid_file, "w") as f:
+            f.write(str(os.getpid()))
+
+        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+        fetcher = NotificationFetcher(data_manager, gui)
+
+        logger.info(f"Starting i3-notifier.")
+        try:
+            GLib.MainLoop().run()
+        except:
+            logger.info("Exiting Glib.MainLoop")
+            data_manager.dump()
+        finally:
+            if os.path.exists(pid_file):
+                os.remove(pid_file)
+
+    if nodaemon:
+        run()
+    else:
+        with daemon.DaemonContext(
+            pidfile=daemon.pidfile.PIDLockFile(pid_file),
+            signal_map={signal.SIGTERM: dump_and_exit},
+            files_preserve=files_preserve,
+        ):
+            run()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="i3-notifier daemon")
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging. Logs will be written to /tmp/i3-notifier.log.",
+    )
+    parser.add_argument(
+        "--config",
+        "-c",
+        help="Path to custom user configuration file. Defaults to $XDG_CONFIG_HOME/i3/i3_notifier_config.py or ~/.config/i3/i3_notifier_config.py if not specified.",
+    )
+    parser.add_argument(
+        "--nodaemon",
+        action="store_true",
+        help="Run in the foreground instead of as a daemon.",
+    )
+    parser.add_argument(
+        "--dump",
+        action="store_true",
+        help="Command the running daemon to dump notifications to file and exit.",
+    )
+    parser.add_argument(
+        "--kill",
+        action="store_true",
+        help="Kill the running daemon instance and exit.",
+    )
+    args = parser.parse_args()
+
+    if args.dump:
+        bus = dbus.SessionBus()
+        try:
+            obj = bus.get_object(
+                "org.freedesktop.Notifications", "/org/freedesktop/Notifications"
+            )
+            obj.DumpNotifications(dbus_interface="org.freedesktop.Notifications")
+            print("Notifications dumped to /tmp/i3-notifier.dump")
+            sys.exit(0)
+        except dbus.exceptions.DBusException as e:
+            print(f"Error communicating with daemon: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    if args.kill:
+        pid_file = "/tmp/i3-notifier.pid"
+        if os.path.exists(pid_file):
+            try:
+                with open(pid_file) as f:
+                    pid = int(f.read().strip())
+                os.kill(pid, signal.SIGTERM)
+                print(f"Sent SIGTERM to process {pid}")
+                sys.exit(0)
+            except ProcessLookupError:
+                print(f"Process {pid} not found. Cleaning up pid file.")
+                os.remove(pid_file)
+                sys.exit(0)
+            except Exception as e:
+                print(f"Error killing process: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            print("i3-notifier is not running (pid file not found).")
+            sys.exit(0)
+
+    global files_preserve
+
+    if args.debug:
+        if args.nodaemon:
+            handler = logging.StreamHandler(sys.stderr)
+        else:
+            handler = logging.FileHandler("/tmp/i3-notifier.log", "w")
+            files_preserve.append(handler.stream.fileno())
+
+        handler.setFormatter(
+            logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
+        )
+        logger.addHandler(handler)
+        logger.setLevel(logging.INFO)
+
+    run_daemon(config_path=args.config, nodaemon=args.nodaemon)
+
+
+if __name__ == "__main__":
+    main()