pytodo-qt 0.2.0__py3-none-any.whl

pytodo_qt-0.2.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: pytodo-qt
+Version: 0.2.0
+Summary: A simple To-Do list app written in PyQt5
+Author-email: Michael Berry <trismegustis@gmail.com>
+License: GPLv3
+Project-URL: Homepage, https://github.com/berrym/todo
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: COPYING
+Requires-Dist: PyQt5
+Requires-Dist: pycryptodomex
+
+# To-Do
+
+A simple to-do list program.
+
+## Description
+
+A small application to manage multiple to-do lists written in Python 3 and Qt5
+
+## Getting started
+
+* Clone the git repository from https://github.com/berrym/todo.git
+
+* Install a recent version of Python, needs version 3.8+.
+
+* A requirements.txt is provided in the repository so required packages can be installed using pip.
+    * pip install -r requirements.txt --user
+
+### Executing program
+
+The main script can be executed from the command line, e.g.
+
+* python3 todo.py
+
+## Help
+
+python3 todo.py --help
+
+## Authors
+
+Copyright 2020
+Michael Berry <trismegustis@gmail.com>
+
+## Version History
+* 0.1.1
+    * Needs Python 3.8 for walrus operator.
+    * Improved dialogs for syncing.
+    * Serialize network I/O with json.
+
+* 0.1.0
+    * Initial Release
+
+## License
+
+This project is licensed under the GNU General Public License version 3, or at your option any later version.
+
+See the COPYING file included in the git repository.

pytodo_qt-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+todo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+todo/__main__.py,sha256=71QnTJRRMg-gx4xjTyhoXkYM5idgnb2WnlsVRLn_fqk,3190
+todo/core/Logger.py,sha256=xx9V4Dq54hDg7TmkEY-FvkUl4cTITUn8NHe1wTCX72w,1261
+todo/core/TodoDataBase.py,sha256=y1etUExcdHZ85GhYQWQvTWGBRh3b-7oLet6IcRVjDd4,8323
+todo/core/__init__.py,sha256=FUqE5ViWxy7Sn_n3pxfJrpKRJY21ry2FuJwD7T16AZY,900
+todo/core/json_helpers.py,sha256=h3CXVbbQ4KrMvrpEcsekZxQNqBi7JUSk6IZpbG9C9co,2879
+todo/core/settings.py,sha256=c_eiX9bf9tCpZAsz_2mq4JejgcJ_Z71R15_bVLPn-Po,627
+todo/crypto/AESCipher.py,sha256=cf7YBbxN-K8czTIrXuLVeEGpo5quVn3TNArol1o9JRU,1768
+todo/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+todo/gui/AddTodoDialog.py,sha256=kUYbMOqpkGLVSYcClXfu1HO6E4SuGMtVCjTleNPZQjw,2624
+todo/gui/MainWindow.py,sha256=bLyX105tUqOJ9f5Uad0A4JsPUc1Vmkt3jF_CqUhuxIc,33511
+todo/gui/SyncDialog.py,sha256=nqW_khAFQ6PcEveHgDDrSVGsjpdCUaI7z4MDagoALv8,3206
+todo/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+todo/gui/icons/minus.png,sha256=PoaZl2RAW8wrkOBvz7bY03xEAdaBNd6HNKaodHbgdMc,217
+todo/gui/icons/plus.png,sha256=VywdidKhN2IdJLPkBVQB3O2GmFXzfSDMV1rLkpKDoGg,287
+todo/gui/icons/todo.png,sha256=kBRWlulLIqDxB5-XtlCz-OYhzrjyj5eEWN36nXWMYzI,659
+todo/net/__init__.py,sha256=-PEFQDpZYUD-aHhMYpJE1NMh92J831ifUCfs10rP5gc,538
+todo/net/sync_operations.py,sha256=TSa7p-tgdd6jiwcQ1Cy3PNJw26eqRlVRrYFqLc9LNz8,279
+todo/net/tcp_client_lib.py,sha256=wcMwfSuZ2EFfF6AaAjYnvOR4xyjheZUqf_hwCALRGiw,4478
+todo/net/tcp_server_lib.py,sha256=tEvDlc6eZTfZ-iCQEhzhWhu94Hdaw_snkeUcMKsXcsE,4638
+pytodo_qt-0.2.0.dist-info/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+pytodo_qt-0.2.0.dist-info/METADATA,sha256=S_kYzdnr2X8G7iES0e8dZLNA5gDt1-XFUEXEWIkamYc,1528
+pytodo_qt-0.2.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+pytodo_qt-0.2.0.dist-info/entry_points.txt,sha256=ywI6kRYcR3cVBDg62_kvFicV4FPmk9ItG6jEKndNXqg,44
+pytodo_qt-0.2.0.dist-info/top_level.txt,sha256=c1x0MAVpTPy2QFoNZ9fz48_PoX9pcGKJOwNu8vee_hs,5
+pytodo_qt-0.2.0.dist-info/RECORD,,

pytodo_qt-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytodo_qt-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+todo = todo.__main__:main

pytodo_qt-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+todo

todo/__main__.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+
+"""__main__.py
+
+A to-do list program written in Python using Qt5
+
+Copyright (C) 2024 Michael Berry <trismegustis@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import argparse
+import os
+import sys
+from PyQt5 import QtWidgets
+
+from todo.core.Logger import Logger
+from todo.core import settings, TodoDataBase
+from todo.gui import MainWindow
+
+
+logger = Logger(__name__)
+
+
+# Main function
+def main():
+    location = ""
+    for i in range(0, len(sys.path)):
+        if sys.path[i].__contains__("site-packages"):
+            location = sys.path[i]
+            location += "/todo"
+            os.chdir(location)
+            break
+
+    if location == "":
+        logger.log.exception("Unknown installation or invocation, exiting")
+        sys.exit(0)
+
+    # create a command line arg_parser
+    arg_parser = argparse.ArgumentParser(
+        prog="To-Do",
+        description="To-Do List Program",
+        epilog="Copyright Michael Berry 2020",
+    )
+
+    # add network server command group
+    server_group = arg_parser.add_argument_group("Server Commands")
+
+    # add options
+    server_group.add_argument(
+        "-s",
+        "--run-server",
+        action="store",
+        type=str,
+        choices=["yes", "no"],
+        help="run a simple to-do list network server",
+    )
+
+    server_group.add_argument(
+        "-a",
+        "--allow-pull",
+        action="store",
+        type=str,
+        choices=["yes", "no"],
+        help="allow remote users to grab your lists",
+    )
+
+    server_group.add_argument(
+        "-A",
+        "--allow-push",
+        action="store",
+        type=str,
+        choices=["yes", "no"],
+        help="allow remote users to send you their lists",
+    )
+
+    server_group.add_argument(
+        "-i", "--ip", type=str, help="set the servers ip addresses."
+    )
+
+    server_group.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        help="specify which port the network server will bind to",
+    )
+
+    arg_parser.add_argument(
+        "-V", "--version", action="version", version=f"%(prog)s v{settings.__version__}"
+    )
+
+    # parse args then convert to dict format
+    args = arg_parser.parse_args()
+    for k, v in vars(args).items():
+        if v is not None:
+            settings.options[k] = v
+
+    # create a to-do database
+    settings.db = TodoDataBase.CreateTodoDataBase()
+
+    # create a QApplication, the main window, then hand over control to Qt
+    app = QtWidgets.QApplication(sys.argv)
+    _ = MainWindow.CreateMainWindow()
+    sys.exit(app.exec())
+
+
+# Main? - Program entry point
+if __name__ == "__main__":
+    main()

todo/core/Logger.py

@@ -0,0 +1,47 @@
+"""Logger.py
+
+A Generic logging class.
+"""
+
+import logging
+import os
+import sys
+
+home_dir = os.getenv("HOME")
+if home_dir is not None:
+    todo_dir = os.path.join(home_dir, ".todo")
+else:
+    print("Error: unable to write log file, exiting")
+    sys.exit(1)
+
+log_fn = os.path.join(todo_dir, "todo.log")
+
+
+class Logger:
+    """A flexible logger."""
+
+    def __init__(
+        self,
+        module_name,
+        file_name=log_fn,
+        file_mode="w",
+        file_handler_level=logging.DEBUG,
+        file_handler_format="%(asctime)-15s [%(threadName)-12s][%(levelname)-8s]  %(message)s",
+        console_handler=logging.StreamHandler(),
+        console_handler_level=logging.DEBUG,
+        console_handler_format=logging.Formatter(
+            "%(asctime)-15s [%(threadName)-12s][%(levelname)-8s]  %(message)s"
+        ),
+    ):
+        """Initialize the logger."""
+        logging.basicConfig(
+            level=file_handler_level,
+            format=file_handler_format,
+            filename=file_name,
+            filemode=file_mode,
+        )
+
+        self.log = logging.getLogger(module_name)
+        console_handler.setLevel(console_handler_level)
+        console_handler.setFormatter(console_handler_format)
+        self.log.addHandler(console_handler)

todo/core/TodoDataBase.py

@@ -0,0 +1,234 @@
+"""TodoDataBase.py
+
+This module implements the to-do database.
+"""
+
+import configparser
+import os
+import sys
+import threading
+
+from todo.core import settings
+from todo.core.Logger import Logger
+from todo.net import tcp_server_lib, tcp_client_lib
+
+
+logger = Logger(__name__)
+
+
+class CreateTodoDataBase:
+    """Maintains a database of to-do lists."""
+
+    def __init__(self):
+        """Create a working database."""
+        logger.log.info("Building the to-do database")
+        self.initialized = False
+        self.server_up = False
+
+        # dictionary of to-do lists, which are lists of dictionaries
+        self.todo_lists = {}
+        self.todo_total = 0
+        self.list_count = 0
+
+        # keep statistics on 'active' to-do list
+        self.active_list = ""
+        self.todo_count = 0
+
+        # create an ini config parser
+        self.config = configparser.ConfigParser()
+        if not os.path.exists(settings.ini_fn):
+            self.write_default_config()
+        self.parse_config()
+
+        # buffer size for sending/receiving data
+        self.buf_size = 4096
+
+        # create a server, and start it in a new thread
+        # the server will create a new thread for each connection established
+        self.net_server = None
+        if settings.options["run"]:
+            self.start_server()
+
+        # create a client
+        self.net_client = tcp_client_lib.DataBaseClient()
+
+    def write_default_config(self):
+        """Write the default configuration for To-Do."""
+        logger.log.info("Writing default configuration to %s", settings.ini_fn)
+        self.config["database"] = {}
+        self.config["database"]["active_list"] = ""
+        self.config["database"]["sort_key"] = "priority"
+        self.config["database"]["reverse_sort"] = "no"
+        self.config["server"] = {}
+        self.config["server"]["key"] = "BewareTheBlackGuardian"
+        self.config["server"]["run"] = "yes"
+        self.config["server"]["address"] = "127.0.0.1"
+        self.config["server"]["port"] = "5364"
+        self.config["server"]["pull"] = "yes"
+        self.config["server"]["push"] = "yes"
+
+        try:
+            with open(settings.ini_fn, "w", encoding="utf-8") as f:
+                self.config.write(f)
+        except IOError as e:
+            logger.log.exception("Unable to write default config: %s", e)
+            sys.exit(1)
+
+    def write_config(self):
+        """Write the current configuration options to config file."""
+        logger.log.info("Writing configuration file %s", settings.ini_fn)
+        self.config["database"]["active_list"] = settings.options["active_list"]
+        self.config["database"]["sort_key"] = settings.options["sort_key"]
+        if settings.options["reverse_sort"]:
+            self.config["database"]["reverse_sort"] = "yes"
+        else:
+            self.config["database"]["reverse_sort"] = "no"
+        if settings.options["run"]:
+            self.config["server"]["run"] = "yes"
+        else:
+            self.config["server"]["run"] = "no"
+        self.config["server"]["address"] = settings.options["address"]
+        self.config["server"]["port"] = str(settings.options["port"])
+        self.config["server"]["pull"] = settings.options["pull"]
+        self.config["server"]["push"] = settings.options["push"]
+
+        try:
+            with open(settings.ini_fn, "w", encoding="utf-8") as f:
+                self.config.write(f)
+                msg = f"Successfully wrote configuration file {settings.ini_fn}"
+                logger.log.info(msg)
+                return True, msg
+        except IOError as e:
+            msg = f"Unable to write default configuration file {settings.ini_fn}: {e}"
+            logger.log.exception(msg)
+            return False, msg
+
+    def parse_config(self):
+        """Parse configuration file.
+
+        If a configuration file exists read it in and set relevant data.
+        """
+        logger.log.info("Parsing configuration file %s", settings.ini_fn)
+        self.config.read(settings.ini_fn)
+
+        for k, v in self.config["database"].items():
+            if k not in settings.options:
+                logger.log.info(f"%r = %r", k, v)
+                settings.options[k] = v
+
+        for k, v in self.config["server"].items():
+            if k not in settings.options:
+                logger.log.info(f"%r = %r", k, v)
+                settings.options[k] = v
+
+        # fix some option types
+        if settings.options["reverse_sort"] == "yes":
+            settings.options["reverse_sort"] = True
+        elif settings.options["reverse_sort"] == "no":
+            settings.options["reverse_sort"] = False
+        else:
+            logger.log.warning("Reverse sort option invalid, defaulting to no")
+            settings.options["reverse_sort"] = False
+
+        if settings.options["run"] == "yes":
+            settings.options["run"] = True
+        elif settings.options["run"] == "no":
+            settings.options["run"] = False
+        else:
+            logger.log.warning("Run network server option invalid, defaulting to yes")
+            settings.options["run"] = True
+
+        try:
+            settings.options["port"] = int(settings.options["port"])
+        except ValueError as e:
+            logger.log.exception("Port must be a number: %s", e)
+            settings.options["port"] = 5364
+
+    def write_text_file(self, fn="todo_list.txt"):
+        """Write active list to plain text file."""
+        if self.todo_count == 0:
+            return
+
+        logger.log.info("Writing todo lists to file %s", fn)
+        try:
+            with open(fn, "w", encoding="utf-8") as f:
+                f.write(f"{self.active_list:*^60}\n\n")
+                for todo in self.todo_lists[self.active_list]:
+                    f.write(f'{todo["reminder"]}\n')
+        except IOError as e:
+            logger.log.exception("Unable to write todo list to %s: %s", fn, e)
+
+    def server_running(self):
+        """Determine if the server is running"""
+        if self.server_up and self.net_server is not None:
+            return True
+        else:
+            return False
+
+    def start_server(self):
+        """Create and start the server."""
+        if self.server_running():
+            return
+
+        logger.log.info("Starting the server")
+        self.net_server = tcp_server_lib.DataBaseServer(
+            (settings.options["address"], settings.options["port"]),
+            tcp_server_lib.TCPRequestHandler,
+        )
+
+        # start network server thread
+        st = threading.Thread(target=self.net_server.serve_forever)
+        st.daemon = True
+        st.start()
+        self.server_up = True
+
+        logger.log.info(
+            "Server up at %s:%d", settings.options["address"], settings.options["port"]
+        )
+
+    def stop_server(self):
+        """Stop and destroy the server."""
+        if self.net_server is not None and self.server_running():
+            logger.log.info("Shutting down the server")
+            self.net_server.shutdown()
+            self.net_server = None
+            self.server_up = False
+            logger.log.info("Server shut down")
+        else:
+            logger.log.exception(
+                "network server does not exist, or is not running, exiting"
+            )
+            sys.exit(1)
+
+    def restart_server(self):
+        """Stop and then restart the server."""
+        if self.server_running():
+            self.stop_server()
+            self.start_server()
+        else:
+            self.start_server()
+
+    def sync_pull(self, host):
+        """Perform a client pull."""
+        return self.net_client.sync_pull(host)
+
+    def sync_push(self, host):
+        """Perform a client push."""
+        return self.net_client.sync_push(host)
+
+    def sort_active_list(self):
+        """Sort the active to-do list."""
+        logger.log.info("Sorting list %s", self.active_list)
+        self.todo_lists[self.active_list].sort(
+            key=lambda todo_list: todo_list[settings.options["sort_key"]],
+            reverse=settings.options["reverse_sort"],
+        )
+
+    def todo_index(self, reminder):
+        """Return the index location of the to-do matching reminder."""
+        i = 0
+        for todo in self.todo_lists[self.active_list]:
+            if todo["reminder"] == reminder:
+                return i
+            else:
+                i += 1

todo/core/__init__.py

@@ -0,0 +1,35 @@
+"""__init__.py
+
+todo.core: A decorator to make security checks on the to-do database.
+"""
+
+import sys
+
+from PyQt5 import QtWidgets
+
+from todo.core import settings
+from todo.core.Logger import Logger
+
+
+def error_on_none_db(func):
+    """Check if settings.db is valid and run func or error out if it is None."""
+
+    logger = Logger(func.__name__)
+
+    def wrapper(*args, **kwargs):
+        """Wrap around func and check settings.db"""
+
+        if settings.db is not None:
+            try:
+                result = func(*args, **kwargs)
+                return result
+            except OSError as e:
+                logger.log.exception(f"To-Do error: {e}")
+                return
+        else:
+            msg = "Database does not exist, exiting"
+            QtWidgets.QMessageBox.critical(None, "Database Error", msg)
+            logger.log.exception(msg)
+            sys.exit(1)
+
+    return wrapper

todo/core/json_helpers.py

@@ -0,0 +1,89 @@
+import json
+import os
+import sys
+
+from todo.core import error_on_none_db, settings
+from todo.core.Logger import Logger
+
+
+logger = Logger(__name__)
+
+
+def merge_todo_lists(*todo_lists):
+    """Merge to-do lists keeping only unique entries."""
+    logger.log.info("Merging to-do lists")
+    new_lists = {}
+    for list_entry in todo_lists:
+        for k in list_entry:
+            new_lists[k] = list_entry[k]
+
+    return new_lists
+
+
+@error_on_none_db
+def read_json_data(fn=settings.lists_fn):
+    """Read in to-do lists from a JSON file."""
+    if not os.path.exists(fn):
+        msg = f"JSON file {fn} does not exist"
+        logger.log.warning(msg)
+        return False, msg
+
+    logger.log.info("Reading JSON file %s", fn)
+    try:
+        with open(fn, "r", encoding="utf-8") as f:
+            # Merge lists
+            if len(settings.db.todo_lists) > 0:
+                todo_lists = json.load(f)
+                new_lists = merge_todo_lists(settings.db.todo_lists, todo_lists)
+                settings.db.todo_lists = new_lists
+            else:
+                settings.db.todo_lists = json.load(f)
+    except IOError as e:
+        logger.log.exception("Error reading JSON file %s: %s", fn, e)
+        return False, e
+
+    # set active list
+    if settings.options is not None and "active_list" in settings.options:
+        if settings.options["active_list"]:
+            settings.db.active_list = settings.options["active_list"]
+        elif len(settings.db.todo_lists) == 0:
+            msg = "No JSON data to read"
+            logger.log.warning(f"{msg}")
+            return False, msg
+        else:
+            for list_entry in settings.db.todo_lists:
+                settings.db.active_list = list_entry
+                logger.log.info("%s set as active_list", list_entry)
+    else:
+        logger.log.exception("settings.options does not exist, exiting")
+        sys.exit(1)
+
+    settings.db.list_count = len(settings.db.todo_lists.keys())
+    settings.db.todo_total = 0
+    for list_entry in settings.db.todo_lists.values():
+        settings.db.todo_total += len(list_entry)
+
+    msg = f"Successfully read JSON file {fn}"
+    logger.log.info(f"{msg}")
+    return True, msg
+
+
+@error_on_none_db
+def write_json_data(fn=settings.lists_fn):
+    """Write to-do lists as a JSON file."""
+    logger.log.info("Writing JSON file %s", fn)
+    try:
+        with open(fn, "w+", encoding="utf-8") as f:
+            if settings.db.todo_lists is not None:
+                json.dump(settings.db.todo_lists, f, indent=2)
+            else:
+                logger.log.exception("settings.db.todo_lists does not exist, exiting")
+                sys.exit(1)
+    except IOError as e:
+        msg = f"Error writing JSON file {fn}: {e}"
+        logger.log.exception(msg)
+        return False, msg
+
+    msg = f"Successfully wrote JSON file {fn}"
+    logger.log.info(msg)
+    return True, msg

todo/core/settings.py

@@ -0,0 +1,30 @@
+"""settings.py
+
+This module creates To-Do core global variables and functions.
+"""
+
+import sys
+import os
+
+__version__ = "0.2.0"
+options = {}
+db = None
+
+home_dir = os.getenv("HOME")
+if home_dir is not None:
+    todo_dir = os.path.join(home_dir, ".todo")
+else:
+    print("Error: unable to write log file, exiting")
+    sys.exit(1)
+
+if not os.path.exists(todo_dir):
+    try:
+        os.mkdir(todo_dir)
+    except OSError as e:
+        print(f"Error creating To-Do configuration directory: {e}")
+        sys.exit(1)
+
+
+# private files
+ini_fn = os.path.join(todo_dir, "todo.ini")
+lists_fn = os.path.join(todo_dir, "todo_lists.json")