Remove legacy log table and bump version to 2.0.0a1

- Remove Log class from table.py
- Remove _log property and all _log() calls from Table class
- Remove log property from Schema class
- Remove ~log table special handling in heading.py
- Remove test_log.py
- Bump version from 0.14.6 to 2.0.0a1
- Remove version length assertion (was only for log table compatibility)

The log table was an outdated approach to event logging. Modern systems
should use standard Python logging, external log aggregation services,
or database audit logs instead.

Test results: 470 passed, 2 skipped

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dimitri-yatsenko

src/datajoint/heading.py

@@ -230,9 +230,6 @@ def _init_from_database(self):
             as_dict=True,
         ).fetchone()
         if info is None:
-            if table_name == "~log":
-                logger.warning("Could not create the ~log table")
-                return
             raise DataJointError(
                 "The table `{database}`.`{table_name}` is not defined.".format(table_name=table_name, database=database)
             )

src/datajoint/schemas.py

@@ -11,7 +11,7 @@
 from .heading import Heading
 from .jobs import JobTable
 from .settings import config
-from .table import FreeTable, Log, lookup_class_name
+from .table import FreeTable, lookup_class_name
 from .user_tables import Computed, Imported, Lookup, Manual, Part, _get_tier
 from .utils import to_camel_case, user_choice
 
@@ -63,7 +63,6 @@ def __init__(
         :param add_objects: a mapping with additional objects to make available to the context in which table classes
         are declared.
         """
-        self._log = None
         self.connection = connection
         self.database = None
         self.context = context
@@ -134,8 +133,6 @@ def activate(
                 raise DataJointError(
                     "Schema `{name}` does not exist and could not be created. Check permissions.".format(name=schema_name)
                 )
-            else:
-                self.log("created")
         self.connection.register(self)
 
         # decorate all tables already decorated
@@ -225,13 +222,6 @@ def _decorate_table(self, table_class, context, assert_declared=False):
                 else:
                     instance.insert(contents, skip_duplicates=True)
 
-    @property
-    def log(self):
-        self._assert_exists()
-        if self._log is None:
-            self._log = Log(self.connection, self.database)
-        return self._log
-
     def __repr__(self):
         return "Schema `{name}`\n".format(name=self.database)
 

src/datajoint/table.py

@@ -5,7 +5,6 @@
 import json
 import logging
 import mimetypes
-import platform
 import re
 import uuid
 from datetime import datetime, timezone
@@ -29,7 +28,6 @@
 from .staged_insert import staged_insert1 as _staged_insert1
 from .storage import StorageBackend, build_object_path, verify_or_create_store_metadata
 from .utils import get_master, is_camel_case, user_choice
-from .version import __version__ as version
 
 logger = logging.getLogger(__name__.split(".")[0])
 
@@ -68,7 +66,6 @@ class Table(QueryExpression):
     """
 
     _table_name = None  # must be defined in subclass
-    _log_ = None  # placeholder for the Log table object
 
     # These properties must be set by the schema decorator (schemas.py) at class level
     # or by FreeTable at instance level
@@ -113,8 +110,6 @@ def declare(self, context=None):
         except AccessError:
             # skip if no create privilege
             pass
-        else:
-            self._log("Declared " + self.full_table_name)
 
     def alter(self, prompt=True, context=None):
         """
@@ -144,7 +139,6 @@ def alter(self, prompt=True, context=None):
                     self.__class__._heading = Heading(table_info=self.heading.table_info)
                     if prompt:
                         logger.info("Table altered")
-                    self._log("Altered " + self.full_table_name)
 
     def from_clause(self):
         """
@@ -261,16 +255,6 @@ def full_table_name(self):
             )
         return r"`{0:s}`.`{1:s}`".format(self.database, self.table_name)
 
-    @property
-    def _log(self):
-        if self._log_ is None:
-            self._log_ = Log(
-                self.connection,
-                database=self.database,
-                skip_logging=self.table_name.startswith("~"),
-            )
-        return self._log_
-
     @property
     def object_storage(self) -> StorageBackend | None:
         """Get the default object storage backend for this table."""
@@ -627,7 +611,6 @@ def delete_quick(self, get_count=False):
         query = "DELETE FROM " + self.full_table_name + self.where_clause()
         self.connection.query(query)
         count = self.connection.query("SELECT ROW_COUNT()").fetchone()[0] if get_count else None
-        self._log(query[:255])
         return count
 
     def delete(
@@ -804,7 +787,6 @@ def drop_quick(self):
             query = "DROP TABLE %s" % self.full_table_name
             self.connection.query(query)
             logger.info("Dropped table %s" % self.full_table_name)
-            self._log(query[:255])
         else:
             logger.info("Nothing to drop: table %s is not declared" % self.full_table_name)
 
@@ -1122,76 +1104,3 @@ def __init__(self, conn, full_table_name):
 
     def __repr__(self):
         return "FreeTable(`%s`.`%s`)\n" % (self.database, self._table_name) + super().__repr__()
-
-
-class Log(Table):
-    """
-    The log table for each schema.
-    Instances are callable.  Calls log the time and identifying information along with the event.
-
-    :param skip_logging: if True, then log entry is skipped by default. See __call__
-    """
-
-    _table_name = "~log"
-
-    def __init__(self, conn, database, skip_logging=False):
-        self.database = database
-        self.skip_logging = skip_logging
-        self._connection = conn
-        self._heading = Heading(table_info=dict(conn=conn, database=database, table_name=self.table_name, context=None))
-        self._support = [self.full_table_name]
-
-        self._definition = """    # event logging table for `{database}`
-        id       :int unsigned auto_increment     # event order id
-        ---
-        timestamp = CURRENT_TIMESTAMP : timestamp # event timestamp
-        version  :varchar(12)                     # datajoint version
-        user     :varchar(255)                    # user@host
-        host=""  :varchar(255)                    # system hostname
-        event="" :varchar(255)                    # event message
-        """.format(database=database)
-
-        super().__init__()
-
-        if not self.is_declared:
-            self.declare()
-            self.connection.dependencies.clear()
-        self._user = self.connection.get_user()
-
-    @property
-    def definition(self):
-        return self._definition
-
-    def __call__(self, event, skip_logging=None):
-        """
-
-        :param event: string to write into the log table
-        :param skip_logging: If True then do not log. If None, then use self.skip_logging
-        """
-        skip_logging = self.skip_logging if skip_logging is None else skip_logging
-        if not skip_logging:
-            try:
-                self.insert1(
-                    dict(
-                        user=self._user,
-                        version=version + "py",
-                        host=platform.uname().node,
-                        event=event,
-                    ),
-                    skip_duplicates=True,
-                    ignore_extra_fields=True,
-                )
-            except DataJointError:
-                logger.info("could not log event in table ~log")
-
-    def delete(self):
-        """
-        bypass interactive prompts and cascading dependencies
-
-        :return: number of deleted items
-        """
-        return self.delete_quick(get_count=True)
-
-    def drop(self):
-        """bypass interactive prompts and cascading dependencies"""
-        self.drop_quick()

src/datajoint/version.py

@@ -1,6 +1,4 @@
 # version bump auto managed by Github Actions:
 # label_prs.yaml(prep), release.yaml(bump), post_release.yaml(edit)
 # manually set this version will be eventually overwritten by the above actions
-__version__ = "0.14.6"
-
-assert len(__version__) <= 10  # The log table limits version to the 10 characters
+__version__ = "2.0.0a1"