chesscalc 2.0.0__py3-none-any.whl

chesscalc/__init__.py

@@ -0,0 +1,71 @@
+# __init__.py
+# Copyright 2008 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Calculate player's performances on a set of games.
+
+Performances are calculated by iteration where each player starts with 0 as
+their performance.  The scale used is +50 for a win, -50 for a loss, and 0 for
+a draw, relative to the opponents performance.  English Chess Federation (ECF)
+grades have the same scale.
+
+The performances are not grades because the results of calculations in previous
+runs are not used in this calculation.
+
+"""
+import os
+import datetime
+import traceback
+
+import solentware_base.core.constants as sb_c_constants
+
+APPLICATION_NAME = "ChessPerfCalc"
+ERROR_LOG = "ErrorLog"
+REPORT_DIRECTORY = "_reports"
+
+# Map database module names to application module
+APPLICATION_DATABASE_MODULE = {
+    sb_c_constants.BERKELEYDB_MODULE: __name__ + ".berkeleydb.database",
+    sb_c_constants.BSDDB3_MODULE: __name__ + ".db.database",
+    sb_c_constants.SQLITE3_MODULE: __name__ + ".sqlite.database",
+    sb_c_constants.APSW_MODULE: __name__ + ".apsw.database",
+    sb_c_constants.DPT_MODULE: __name__ + ".dpt.database",
+    sb_c_constants.UNQLITE_MODULE: __name__ + ".unqlite.database",
+    sb_c_constants.VEDIS_MODULE: __name__ + ".vedis.database",
+    sb_c_constants.DB_TCL_MODULE: __name__ + ".db_tkinter.database",
+    sb_c_constants.LMDB_MODULE: __name__ + ".lmdb.database",
+}
+
+del sb_c_constants
+
+
+def write_error_to_log(directory):
+    """Write the exception to the error log with a time stamp.
+
+    Consider using the ExceptionHandler.report_exception(...) method if
+    the write_error_to_log() call is in an instance of a subclass of the
+    solentware_bind.gui.exceptionhandler.ExceptionHandler class.
+
+    """
+    with open(
+        os.path.join(directory, ERROR_LOG),
+        "a",
+        encoding="utf-8",
+    ) as file:
+        file.write(
+            "".join(
+                (
+                    "\n\n\n",
+                    " ".join(
+                        (
+                            APPLICATION_NAME,
+                            "exception report at",
+                            datetime.datetime.now().isoformat(),
+                        )
+                    ),
+                    "\n\n",
+                    traceback.format_exc(),
+                    "\n\n",
+                )
+            )
+        )

chesscalc/apsw/__init__.py

@@ -0,0 +1,5 @@
+# __init__.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Identify apsw as a sub-package in chesscalc."""

chesscalc/apsw/database.py

@@ -0,0 +1,46 @@
+# database.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Chess Performance Calculation database using Sqlite3 via apsw."""
+
+from solentware_base import apsw_database
+
+from ..core.filespec import FileSpec
+from ..basecore import database
+
+
+class Database(database.Database, apsw_database.Database):
+    """Methods and data structures to create, open, and close database."""
+
+    _deferred_update_process = "chesscalc.apsw.database_du"
+
+    def __init__(
+        self,
+        sqlite3file,
+        use_specification_items=None,
+        dpt_records=None,
+        **kargs,
+    ):
+        """Define database specification then delegate."""
+        names = FileSpec(
+            use_specification_items=use_specification_items,
+            dpt_records=dpt_records,
+        )
+
+        super().__init__(
+            names,
+            sqlite3file,
+            use_specification_items=use_specification_items,
+            **kargs,
+        )
+
+    def delete_database(self):
+        """Close and delete the open chess results database."""
+        return super().delete_database(
+            (
+                self.database_file,
+                "-".join((self.database_file, "lock")),
+                "-".join((self.database_file, "journal")),
+            )
+        )

chesscalc/apsw/database_du.py

@@ -0,0 +1,35 @@
+# database_du.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Chess performance database deferred update using Sqlite 3 via apsw."""
+
+from solentware_base import apswdu_database
+from solentware_base import apsw_database
+
+from ..shared import litedu
+from ..shared import alldu
+
+
+class ApswDatabaseduError(Exception):
+    """Exception class for apsw.database_du module."""
+
+
+class Database(alldu.Alldu, litedu.Litedu, apswdu_database.Database):
+    """Provide custom deferred update for chess performance database."""
+
+    def __init__(self, sqlite3file, **kargs):
+        """Delegate with ApswDatabaseduError as exception class."""
+        super().__init__(sqlite3file, ApswDatabaseduError, **kargs)
+
+
+class DatabaseSU(alldu.Alldu, litedu.Litedu, apsw_database.Database):
+    """Provide custom deferred update for chess performance database."""
+
+    def __init__(self, sqlite3file, **kargs):
+        """Delegate with ApswDatabaseduError as exception class."""
+        super().__init__(sqlite3file, ApswDatabaseduError, **kargs)
+
+    # Class structure implies this is not an override at present.
+    def deferred_update_housekeeping(self):
+        """Override to do nothing."""

chesscalc/basecore/__init__.py

@@ -0,0 +1,5 @@
+# __init__.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Identify basecore as a sub-package in chesscalc."""

chesscalc/basecore/database.py

@@ -0,0 +1,66 @@
+# database.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Database methods common to all database engine interfaces."""
+
+import os
+import shutil
+
+from .. import APPLICATION_NAME, ERROR_LOG, REPORT_DIRECTORY
+
+
+class Database:
+    """Provide methods common to all database engine interfaces."""
+
+    # Non *_du database actions are done in separate threads by default,
+    # not the main thread.  Override with 'can_use_thread = False' in
+    # subclasses if necessary.
+    # For SQLite3 the apsw interface is happy with the default, but the
+    # sqlite3 interface gives a sqlite3.programmingerror exception.
+    # For Berkeley DB the bsddb3 and berkeleydb interfaces are happy with
+    # the default, but the tcl via tkinter interface gives a RuntimeError
+    # exception.
+    can_use_thread = True
+
+    def use_deferred_update_process(self):
+        """Return path to deferred update module."""
+        return self._deferred_update_process
+
+    def open_database(self, files=None):
+        """Return '' to fit behaviour of dpt version of this method."""
+        super().open_database(files=files)
+        return ""
+
+    def delete_database(self, names):
+        """Delete database and return message about items not deleted."""
+        listnames = set(n for n in os.listdir(self.home_directory))
+        homenames = set(n for n in names if os.path.basename(n) in listnames)
+        for name in (ERROR_LOG, REPORT_DIRECTORY):
+            if name in listnames:
+                homenames.add(name)
+        if len(listnames - set(os.path.basename(h) for h in homenames)):
+            message = "".join(
+                (
+                    "There is at least one file or folder in\n\n",
+                    self.home_directory,
+                    "\n\nwhich may not be part of the database.  These items ",
+                    "have not been deleted by ",
+                    APPLICATION_NAME,
+                    ".",
+                )
+            )
+        else:
+            message = None
+        self.close_database()
+        for hnm in homenames:
+            hnm = os.path.join(self.home_directory, hnm)
+            if os.path.isdir(hnm):
+                shutil.rmtree(hnm, ignore_errors=True)
+            else:
+                os.remove(hnm)
+        try:
+            os.rmdir(self.home_directory)
+        except (FileNotFoundError, OSError):
+            pass
+        return message

chesscalc/berkeleydb/__init__.py

@@ -0,0 +1,5 @@
+# __init__.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Identify berkeleydb as a sub-package in chesscalc."""

chesscalc/berkeleydb/database.py

@@ -0,0 +1,73 @@
+# database.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Chess Performance Calculation database using Berkeley DB via berkeleydb."""
+
+from berkeleydb.db import (
+    # DB_BTREE,
+    # DB_HASH,
+    # DB_RECNO,
+    # DB_DUPSORT,
+    DB_CREATE,
+    DB_RECOVER,
+    DB_INIT_MPOOL,
+    DB_INIT_LOCK,
+    DB_INIT_LOG,
+    DB_INIT_TXN,
+    DB_PRIVATE,
+)
+
+from solentware_base import berkeleydb_database
+
+from ..core.filespec import FileSpec
+from ..basecore import database
+
+
+class Database(database.Database, berkeleydb_database.Database):
+    """Methods and data structures to create, open, and close database."""
+
+    _deferred_update_process = "chesscalc.berkeleydb.database_du"
+
+    def __init__(
+        self,
+        DBfile,
+        use_specification_items=None,
+        dpt_records=None,
+        **kargs,
+    ):
+        """Define database specification and environment then delegate."""
+        dbnames = FileSpec(
+            use_specification_items=use_specification_items,
+            dpt_records=dpt_records,
+        )
+
+        environment = {
+            "flags": (
+                DB_CREATE
+                | DB_RECOVER
+                | DB_INIT_MPOOL
+                | DB_INIT_LOCK
+                | DB_INIT_LOG
+                | DB_INIT_TXN
+                | DB_PRIVATE
+            ),
+        }
+
+        super().__init__(
+            dbnames,
+            DBfile,
+            environment,
+            use_specification_items=use_specification_items,
+            **kargs,
+        )
+
+    def delete_database(self):
+        """Close and delete the open chess results database."""
+        return super().delete_database(
+            (
+                self.database_file,
+                "-".join((self.database_file, "lock")),
+                self.dbenv.get_lg_dir().decode(),
+            )
+        )

chesscalc/berkeleydb/database_du.py

@@ -0,0 +1,63 @@
+# database_du.py
+# Copyright 2023 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Chess performance deferred update using Berkeley DB via berkeleydb."""
+
+import berkeleydb.db
+
+from solentware_base import berkeleydbdu_database
+from solentware_base import berkeleydb_database
+
+from ..shared import dbdu
+from ..shared import alldu
+
+
+class BerkeleydbDatabaseduError(Exception):
+    """Exception class for berkeleydb.database_du module."""
+
+
+class Database(alldu.Alldu, dbdu.Dbdu, berkeleydbdu_database.Database):
+    """Provide custom deferred update for chess performance database."""
+
+    def __init__(self, DBfile, **kargs):
+        """Delegate with BerkeleydbDatabaseduError as exception class."""
+        super().__init__(
+            DBfile,
+            BerkeleydbDatabaseduError,
+            (
+                berkeleydb.db.DB_CREATE
+                | berkeleydb.db.DB_RECOVER
+                | berkeleydb.db.DB_INIT_MPOOL
+                | berkeleydb.db.DB_INIT_LOCK
+                | berkeleydb.db.DB_INIT_LOG
+                | berkeleydb.db.DB_INIT_TXN
+                | berkeleydb.db.DB_PRIVATE
+            ),
+            **kargs
+        )
+
+
+class DatabaseSU(alldu.Alldu, dbdu.Dbdu, berkeleydb_database.Database):
+    """Provide custom deferred update for chess performance database."""
+
+    def __init__(self, DBfile, **kargs):
+        """Delegate with BerkeleydbDatabaseduError as exception class."""
+        super().__init__(
+            DBfile,
+            BerkeleydbDatabaseduError,
+            (
+                berkeleydb.db.DB_CREATE
+                | berkeleydb.db.DB_RECOVER
+                | berkeleydb.db.DB_INIT_MPOOL
+                | berkeleydb.db.DB_INIT_LOCK
+                | berkeleydb.db.DB_INIT_LOG
+                | berkeleydb.db.DB_INIT_TXN
+                | berkeleydb.db.DB_PRIVATE
+            ),
+            **kargs
+        )
+
+    # Class structure implies this is not an override at present.
+    def deferred_update_housekeeping(self):
+        """Override to do nothing."""

chesscalc/calculate.py

@@ -0,0 +1,79 @@
+# calculate.py
+# Copyright 2012 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Calculate performances from a file of chess game results."""
+
+if __name__ == "__main__":
+    import multiprocessing
+
+    from . import APPLICATION_NAME
+
+    multiprocessing.set_start_method("spawn")
+    del multiprocessing
+
+    try:
+        from solentware_misc.gui.startstop import (
+            start_application_exception,
+            stop_application,
+            application_exception,
+        )
+    except Exception as error:
+        import tkinter.messagebox
+
+        try:
+            tkinter.messagebox.showerror(
+                title="Start Exception",
+                message=".\n\nThe reported exception is:\n\n".join(
+                    (
+                        " ".join(
+                            (
+                                "Unable to import",
+                                "solentware_misc.gui.startstop module",
+                            )
+                        ),
+                        str(error),
+                    )
+                ),
+            )
+        except tkinter.TclError:
+            pass
+        raise SystemExit(
+            "Unable to import start application utilities"
+        ) from error
+    try:
+        from .gui.calculator import Calculator
+    except Exception as error:
+        start_application_exception(
+            error, appname=APPLICATION_NAME, action="import"
+        )
+        raise SystemExit(
+            " import ".join(("Unable to", APPLICATION_NAME))
+        ) from error
+    try:
+        app = Calculator()
+    except Exception as error:
+        start_application_exception(
+            error, appname=APPLICATION_NAME, action="initialise"
+        )
+        raise SystemExit(
+            " initialise ".join(("Unable to", APPLICATION_NAME))
+        ) from error
+    try:
+        app.widget.mainloop()
+    except SystemExit:
+        stop_application(app, app.widget)
+        raise
+    except Exception as error:
+        application_exception(
+            error,
+            app,
+            app.widget,
+            title="Chess Performace Calculator",
+            appname=APPLICATION_NAME,
+        )
+        raise SystemExit(
+            " reporting exception in ".join(
+                ("Exception while", APPLICATION_NAME)
+            )
+        ) from error

chesscalc/core/__init__.py

@@ -0,0 +1,5 @@
+# __init__.py
+# Copyright 2009 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""Identify core as a sub-package in chesscalc."""

chesscalc/core/apply_identities.py

@@ -0,0 +1,219 @@
+# apply_identities.py
+# Copyright 2024 Roger Marsh
+# Licence: See LICENCE (BSD licence)
+
+"""This module provides functions to verify and apply player identities.
+
+Identities exported from a performance calculation database are verified
+for consistency and applied to a database if consistent.
+
+"""
+
+from . import playerrecord
+from . import filespec
+
+
+class _ApplyIdentitiesReport(list):
+    """Report the outcome of verifying and applying player identities."""
+
+    def __init__(self):
+        """Define the initial report which also means no problems found."""
+        self.messages_exist = False
+
+    def append(self, identity):
+        """Delegate and note if identity has a message."""
+        super().append(identity)
+        if identity.message is not None:
+            self.messages_exist = True
+
+
+class _NameStatus:
+    """Classify names by representation on database.
+
+    A name may: not exist, be new, be identified as primary, or an alias
+    of a primary.
+    """
+
+    def __init__(self, names):
+        """Initialise buckets for names."""
+        self.names = names
+        self.not_on_database = set()
+        self.not_identified = {}
+        self.identified_primary = {}
+        self.identified_alias = {}
+        self.chosen_name = None
+        self.message = None
+
+    def classify_names(self, database):
+        """Put each name in the appropriate bucket."""
+        not_on_database = self.not_on_database
+        not_identified = self.not_identified
+        identified_primary = self.identified_primary
+        identified_alias = self.identified_alias
+        value = playerrecord.PersonValue()
+        person_record = playerrecord.PlayerDBrecord(
+            valueclass=playerrecord.PersonDBvalue
+        )
+        encode_record_selector = database.encode_record_selector
+        for name in self.names:
+            value.load_alias_index_key(repr(name))
+            personlist = database.recordlist_key(
+                filespec.PLAYER_FILE_DEF,
+                filespec.PLAYER_ALIAS_FIELD_DEF,
+                key=encode_record_selector(value.alias_index_key()),
+            )
+            count = personlist.count_records()
+            if count > 1:
+                self.message = "Player by name record is not unique."
+                return
+            record = personlist.create_recordsetbase_cursor(
+                internalcursor=True
+            ).first()
+            if record:
+                not_identified[name] = record
+                continue
+            personlist = database.recordlist_key(
+                filespec.PLAYER_FILE_DEF,
+                filespec.PERSON_ALIAS_FIELD_DEF,
+                key=encode_record_selector(value.alias_index_key()),
+            )
+            count = personlist.count_records()
+            if count > 1:
+                self.message = "Person by name record is not unique."
+                return
+            record = personlist.create_recordsetbase_cursor(
+                internalcursor=True
+            ).first()
+            if record:
+                person_record.load_record(record)
+                alias = person_record.value.alias
+                if alias == person_record.value.identity:
+                    if alias not in identified_primary:
+                        identified_primary[alias] = {name: record}
+                    else:
+                        identified_primary[alias][name] = record
+                    continue
+                if alias not in identified_alias:
+                    identified_alias[alias] = {name: record}
+                else:
+                    identified_alias[alias][name] = record
+                continue
+            not_on_database.add(name)
+
+    def identify_names(self, database):
+        """Make each not identified name an alias of an identified name.
+
+        The name in identified_primary or derived from identified_alias
+        will be the identified name if available.
+
+        Otherwise one of the names in not_identified is picked and noted
+        in chosen_name.
+
+        """
+        value = playerrecord.PersonValue()
+        packer = playerrecord.PlayerDBrecord(
+            valueclass=playerrecord.PersonDBvalue
+        )
+        player_record = playerrecord.PlayerDBrecord()
+        person_record = playerrecord.PlayerDBrecord(
+            valueclass=playerrecord.PersonDBvalue
+        )
+        encode_record_selector = database.encode_record_selector
+        names = self.not_identified.copy()
+        if len(self.identified_primary):
+            chosen_alias, name = list(self.identified_primary.items())[0]
+            record = list(name.values())[0]
+        elif len(self.identified_alias):
+            chosen_alias, name = list(self.identified_alias.items())[0]
+            record = list(name.values())[0]
+        else:
+            chosen_name, record = names.popitem()
+            player_record.load_record(record)
+            chosen_alias = player_record.value.alias
+            self.chosen_name = chosen_name
+            person_record.load_record(record)
+
+            # None is safe because self.srkey == new_record.srkey.
+            # filespec.PLAYER_ALIAS_FIELD_DEF is correct value otherwise
+            # because of how argument is used in edit_record().
+            player_record.edit_record(
+                database, filespec.PLAYER_FILE_DEF, None, person_record
+            )
+
+        packer.load_record(record)
+        person = packer.value.alias_index_key()
+        persongames = database.recordlist_key(
+            filespec.GAME_FILE_DEF,
+            filespec.GAME_PLAYER_FIELD_DEF,
+            key=encode_record_selector(person),
+        )
+
+        while len(names):
+            name, record = names.popitem()
+            # value should be PlayerDBvalue but while PersonDBvalue gives
+            # the same answer there is no need to change it.
+            value.load_alias_index_key(repr(name))
+            player_record.load_record(record)
+            person_record.load_record(record)
+            person_record.value.alias = chosen_alias
+
+            # None is safe because self.srkey == new_record.srkey.
+            # filespec.PLAYER_ALIAS_FIELD_DEF is correct value otherwise
+            # because of how argument is used in edit_record().
+            player_record.edit_record(
+                database, filespec.PLAYER_FILE_DEF, None, person_record
+            )
+
+            persongames |= database.recordlist_key(
+                filespec.GAME_FILE_DEF,
+                filespec.GAME_PLAYER_FIELD_DEF,
+                key=encode_record_selector(value.alias_index_key()),
+            )
+        database.file_records_under(
+            filespec.GAME_FILE_DEF,
+            filespec.GAME_PERSON_FIELD_DEF,
+            persongames,
+            encode_record_selector(person),
+        )
+
+
+def verify_and_apply_identities(database, identities):
+    """Return None if identities applied or a message for display if not."""
+    if not database:
+        return None
+    if not identities:
+        return None
+    commit_flag = True
+    report = _ApplyIdentitiesReport()
+    database.start_transaction()
+    try:
+        for identity in identities:
+            name = _NameStatus(identity)
+            report.append(name)
+            name.classify_names(database)
+            if name.message is not None:
+                commit_flag = False
+                continue
+            if (
+                len(set(name.identified_primary).union(name.identified_alias))
+                > 1
+            ):
+                name.message = "More than one database person is referenced."
+                report.messages_exist = True
+                commit_flag = False
+                continue
+        if not commit_flag:
+            return report
+        for identity in report:
+            if not identity.not_identified:
+                continue
+            identity.identify_names(database)
+        # For testing report what has been found.
+        # if commit_flag:
+        #     commit_flag = False
+    finally:
+        if commit_flag:
+            database.commit()
+        else:
+            database.backout()
+    return report