fix(populate): pin parallel populate to the fork start method

The real cause of the py3.14 failure is Python 3.14 changing the multiprocessing
default start method from fork to forkserver. Parallel populate hands the live
table and its open DB connection to workers by process inheritance (fork); under
forkserver the payload is pickled instead, which cannot carry a live connection
and deadlocked the job (after first surfacing as 'cannot pickle itertools.count').

Pin both Pool call sites to a fork context (fork where available, platform
default otherwise). Reverts the earlier Dependencies __getstate__/__setstate__
pickle workaround, which addressed only the symptom. py3.10 (fork default)
already passed; this makes py3.14 use the same proven path.

Author: dimitri-yatsenko

src/datajoint/autopopulate.py

@@ -22,6 +22,14 @@
 
 logger = logging.getLogger(__name__.split(".")[0])
 
+# Parallel populate hands the live table and its open connection to workers by
+# process inheritance, so it requires the `fork` start method. Python 3.14
+# changed the default from `fork` to `forkserver`, which pickles the payload
+# instead — that neither carries a live DB connection nor the table's internal
+# state, and it deadlocks. Pin to `fork` where available (all POSIX platforms);
+# fall back to the platform default elsewhere.
+_MP_START_METHOD = "fork" if "fork" in mp.get_all_start_methods() else None
+
 
 # --- helper functions for multiprocessing --
 
@@ -30,7 +38,8 @@ def _initialize_populate(table: Table, jobs: Job | None, populate_kwargs: dict[s
     """
     Initialize a worker process for multiprocessing.
 
-    Saves the unpickled table to the current process and reconnects to database.
+    Stores the inherited table on the worker process and reconnects to database
+    (the parent closes its connection before forking; each worker reopens one).
 
     Parameters
     ----------
@@ -476,7 +485,9 @@ def _populate_direct(
                 if hasattr(self.connection._conn, "ctx"):
                     del self.connection._conn.ctx
                 with (
-                    mp.Pool(processes, _initialize_populate, (self, None, populate_kwargs)) as pool,
+                    mp.get_context(_MP_START_METHOD).Pool(
+                        processes, _initialize_populate, (self, None, populate_kwargs)
+                    ) as pool,
                     tqdm(desc="Processes: ", total=nkeys) if display_progress else contextlib.nullcontext() as progress_bar,
                 ):
                     for status in pool.imap(_call_populate1, keys, chunksize=1):
@@ -572,7 +583,9 @@ def handler(signum, frame):
                     if hasattr(self.connection._conn, "ctx"):
                         del self.connection._conn.ctx  # SSLContext is not pickleable
                     with (
-                        mp.Pool(processes, _initialize_populate, (self, self.jobs, populate_kwargs)) as pool,
+                        mp.get_context(_MP_START_METHOD).Pool(
+                            processes, _initialize_populate, (self, self.jobs, populate_kwargs)
+                        ) as pool,
                         tqdm(desc="Processes: ", total=nkeys)
                         if display_progress
                         else contextlib.nullcontext() as progress_bar,
@@ -866,8 +879,6 @@ def _update_job_metadata(self, key, start_time, duration, version):
 
         pk_condition = make_condition(self, key, set())
         self.connection.query(
-            f"UPDATE {self.full_table_name} SET "
-            "_job_start_time=%s, _job_duration=%s, _job_version=%s "
-            f"WHERE {pk_condition}",
+            f"UPDATE {self.full_table_name} SET _job_start_time=%s, _job_duration=%s, _job_version=%s WHERE {pk_condition}",
             args=(start_time, duration, version[:64] if version else ""),
         )

src/datajoint/dependencies.py

@@ -140,19 +140,6 @@ def clear(self) -> None:
         self._node_alias_count = itertools.count()  # reset alias IDs for consistency
         super().clear()
 
-    def __getstate__(self) -> dict:
-        # itertools.count is not picklable. Multiprocessing populate pickles the
-        # table (and thus its connection's Dependencies) to worker processes,
-        # where dependencies are reloaded — so the counter is dropped here and
-        # rebuilt in __setstate__ rather than carried across the pickle.
-        state = self.__dict__.copy()
-        state.pop("_node_alias_count", None)
-        return state
-
-    def __setstate__(self, state: dict) -> None:
-        self.__dict__.update(state)
-        self._node_alias_count = itertools.count()
-
     def load(self, force: bool = True, schema_names: set[str] | None = None) -> None:
         """
         Load dependencies for the given schemas.