Run auto-tick with selected Migrators only

conda_forge_tick/cli.py

@@ -149,11 +149,26 @@ def update_upstream_versions(
 
 
 @main.command(name="auto-tick")
+@click.option(
+    "--migrator",
+    "-m",
+    type=str,
+    multiple=True,
+)
+@click.argument(
+    "package",
+    required=False,
+)
 @pass_context
-def auto_tick(ctx: CliContext) -> None:
+def auto_tick(ctx: CliContext, package: str | None, migrator: tuple[str, ...]) -> None:
+    """
+    Run the main bot logic that runs all migrations, updates the graph accordingly, and opens the corresponding PRs.
+
+    If PACKAGE is given, only run the bot for that package, otherwise run the bot for all packages.
+    """
     from . import auto_tick
 
-    auto_tick.main(ctx)
+    auto_tick.main(ctx, package=package, migrator_names=migrator)
 
 
 @main.command(name="make-status-report")
@@ -236,16 +251,22 @@ def make_import_to_package_mapping(
 
 
 @main.command(name="make-migrators")
+@click.option(
+    "--version-only/--all",
+    default=False,
+    help="If given, only initialize the Version migrator.",
+)
 @pass_context
 def make_migrators(
     ctx: CliContext,
+    version_only: bool,
 ) -> None:
     """
     Make the migrators.
     """
     from . import make_migrators as _make_migrators
 
-    _make_migrators.main(ctx)
+    _make_migrators.main(ctx, version_only=version_only)
 
 
 if __name__ == "__main__":

conda_forge_tick/contexts.py

@@ -1,10 +1,17 @@
+from __future__ import annotations
+
 import os
+import tempfile
 import typing
+from collections.abc import Iterator
+from contextlib import contextmanager
 from dataclasses import dataclass
+from pathlib import Path
 
 from networkx import DiGraph
 
 from conda_forge_tick.lazy_json_backends import load
+from conda_forge_tick.utils import get_keys_default
 
 if typing.TYPE_CHECKING:
     from conda_forge_tick.migrators_types import AttrsTypedDict
@@ -24,13 +31,12 @@ class MigratorSessionContext:
     graph: DiGraph = None
     smithy_version: str = ""
     pinning_version: str = ""
-    dry_run: bool = True
 
 
-@dataclass
+@dataclass(frozen=True)
 class FeedstockContext:
     feedstock_name: str
-    attrs: "AttrsTypedDict"
+    attrs: AttrsTypedDict
     _default_branch: str = None
 
     @property
@@ -40,6 +46,95 @@ def default_branch(self):
         else:
             return self._default_branch
 
-    @default_branch.setter
-    def default_branch(self, v):
-        self._default_branch = v
+    @property
+    def git_repo_owner(self) -> str:
+        return "conda-forge"
+
+    @property
+    def git_repo_name(self) -> str:
+        return f"{self.feedstock_name}-feedstock"
+
+    @property
+    def git_href(self) -> str:
+        """
+        A link to the feedstocks GitHub repository.
+        """
+        return f"https://github.com/{self.git_repo_owner}/{self.git_repo_name}"
+
+    @property
+    def automerge(self) -> bool | str:
+        """
+        Get the automerge setting of the feedstock.
+
+        Note: A better solution to implement this is to use the NodeAttributes Pydantic
+        model for the attrs field. This will be done in the future.
+        """
+        return get_keys_default(
+            self.attrs,
+            ["conda-forge.yml", "bot", "automerge"],
+            {},
+            False,
+        )
+
+    @property
+    def check_solvable(self) -> bool:
+        """
+        Get the check_solvable setting of the feedstock.
+
+        Note: A better solution to implement this is to use the NodeAttributes Pydantic
+        model for the attrs field. This will be done in the future.
+        """
+        return get_keys_default(
+            self.attrs,
+            ["conda-forge.yml", "bot", "check_solvable"],
+            {},
+            False,
+        )
+
+    @contextmanager
+    def reserve_clone_directory(self) -> Iterator[ClonedFeedstockContext]:
+        """
+        Reserve a temporary directory for the feedstock repository that will be available within the context manager.
+        The returned context object will contain the path to the feedstock repository in local_clone_dir.
+        After the context manager exits, the temporary directory will be deleted.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            local_clone_dir = Path(tmpdir) / self.git_repo_name
+            local_clone_dir.mkdir()
+            yield ClonedFeedstockContext(
+                **self.__dict__,
+                local_clone_dir=local_clone_dir,
+            )
+
+
+@dataclass(frozen=True, kw_only=True)
+class ClonedFeedstockContext(FeedstockContext):
+    """
+    A FeedstockContext object that has reserved a temporary directory for the feedstock repository.
+    """
+
+    # Implementation Note: Keep this class frozen or there will be consistency issues if someone modifies
+    # a ClonedFeedstockContext object in place - it will not be reflected in the original FeedstockContext object.
+    local_clone_dir: Path
+
+    @contextmanager
+    def reserve_clone_directory(self) -> Iterator[ClonedFeedstockContext]:
+        """
+        This method is a no-op for ClonedFeedstockContext objects because the directory has already been reserved.
+        """
+        yield self
+
+    @property
+    def git_repo_owner(self) -> str:
+        return "conda-forge"
+
+    @property
+    def git_repo_name(self) -> str:
+        return f"{self.feedstock_name}-feedstock"
+
+    @property
+    def git_href(self) -> str:
+        """
+        A link to the feedstocks GitHub repository.
+        """
+        return f"https://github.com/{self.git_repo_owner}/{self.git_repo_name}"

conda_forge_tick/executors.py

@@ -16,9 +16,21 @@ def __exit__(self, *args, **kwargs):
         pass
 
 
-TRLOCK = TRLock()
-PRLOCK = DummyLock()
-DRLOCK = DummyLock()
+GIT_LOCK_THREAD = TRLock()
+GIT_LOCK_PROCESS = DummyLock()
+GIT_LOCK_DASK = DummyLock()
+
+
+@contextlib.contextmanager
+def lock_git_operation():
+    """
+    A context manager to lock git operations - it can be acquired once per thread, once per process,
+    and once per dask worker.
+    Note that this is a reentrant lock, so it can be acquired multiple times by the same thread/process/worker.
+    """
+
+    with GIT_LOCK_THREAD, GIT_LOCK_PROCESS, GIT_LOCK_DASK:
+        yield
 
 
 logger = logging.getLogger(__name__)
@@ -27,10 +39,12 @@ def __exit__(self, *args, **kwargs):
 class DaskRLock(DaskLock):
     """A reentrant lock for dask that is always blocking and never times out."""
 
-    def acquire(self):
-        if not hasattr(self, "_rcount"):
-            self._rcount = 0
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._rcount = 0
+        self._rdata = None
 
+    def acquire(self, *args):
         self._rcount += 1
 
         if self._rcount == 1:
@@ -39,29 +53,29 @@ def acquire(self):
         return self._rdata
 
     def release(self):
-        if not hasattr(self, "_rcount") or self._rcount == 0:
+        if self._rcount == 0:
             raise RuntimeError("Lock not acquired so cannot be released!")
 
         self._rcount -= 1
 
         if self._rcount == 0:
-            delattr(self, "_rdata")
+            self._rdata = None
             return super().release()
         else:
             return None
 
 
 def _init_process(lock):
-    global PRLOCK
-    PRLOCK = lock
+    global GIT_LOCK_PROCESS
+    GIT_LOCK_PROCESS = lock
 
 
 def _init_dask(lock):
-    global DRLOCK
-    # it appears we have to construct the locak by name instead
+    global GIT_LOCK_DASK
+    # it appears we have to construct the lock by name instead
     # of passing the object itself
     # otherwise dask uses a regular lock
-    DRLOCK = DaskRLock(name=lock)
+    GIT_LOCK_DASK = DaskRLock(name=lock)
 
 
 @contextlib.contextmanager
@@ -70,8 +84,8 @@ def executor(kind: str, max_workers: int, daemon=True) -> typing.Iterator[Execut
 
     This allows us to easily use other executors as needed.
     """
-    global DRLOCK
-    global PRLOCK
+    global GIT_LOCK_DASK
+    global GIT_LOCK_PROCESS
 
     if kind == "thread":
         with ThreadPoolExecutor(max_workers=max_workers) as pool_t:
@@ -85,7 +99,7 @@ def executor(kind: str, max_workers: int, daemon=True) -> typing.Iterator[Execut
             initargs=(lock,),
         ) as pool_p:
             yield pool_p
-        PRLOCK = DummyLock()
+        GIT_LOCK_PROCESS = DummyLock()
     elif kind in ["dask", "dask-process", "dask-thread"]:
         import dask
         import distributed
@@ -101,6 +115,6 @@ def executor(kind: str, max_workers: int, daemon=True) -> typing.Iterator[Execut
                 with distributed.Client(cluster) as client:
                     client.run(_init_dask, "cftick")
                     yield ClientExecutor(client)
-                DRLOCK = DummyLock()
+                GIT_LOCK_DASK = DummyLock()
     else:
         raise NotImplementedError("That kind is not implemented")