test: $(app) venv\.test.installed  ci-test: 	set CI=true-	pytest \-		--verbose \-		-p no:sugar \-		--cov-report term \-		--cov-report html:test-results\coverage/ \-		--junit-xml=test-results\junit.xml \-		--benchmark-enable \-		-p no:xdist+	FOR /L %%I IN (0, 1, 9) DO \+		pytest \+			--num-shards 10 \

 test: $(app) venv\.test.installed  ci-test: 	set CI=true-	pytest \-		--verbose \-		-p no:sugar \-		--cov-report term \-		--cov-report html:test-results\coverage/ \-		--junit-xml=test-results\junit.xml \-		--benchmark-enable \-		-p no:xdist+	FOR /L %%I IN (0, 1, 9) DO \+		pytest \+			--num-shards 10 \

 test: $(app) venv\.test.installed  ci-test: 	set CI=true-	pytest \-		--verbose \-		-p no:sugar \-		--cov-report term \-		--cov-report html:test-results\coverage/ \-		--junit-xml=test-results\junit.xml \-		--benchmark-enable \-		-p no:xdist+	FOR /L %%I IN (0, 1, 9) DO \+		pytest \+			--num-shards 10 \

 import contextlib+import logging import struct+import subprocess+import sys from pathlib import Path  import pygit2 -from .repository_version import write_repo_version_config-from . import repo_files+from .exceptions import translate_subprocess_exit_code, NotFound, NO_REPOSITORY+from .repository_version import REPO_VERSIONS+from .working_copy import WorkingCopy +L = logging.getLogger("sno.sno_repo") -# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,-# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,-# but since we differ slightly from a standard git repository, there are a few extra things to take care of. +class SnoRepoFiles:+    """Useful files that are found in `sno_repo.gitdir_path`""" -def _append_checksum(data):-    return data + pygit2.hash(data).raw---INDEX_VERSION = 2-EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)+    # Standard git files:+    HEAD = "HEAD"+    INDEX = "index"+    COMMIT_EDITMSG = "COMMIT_EDITMSG"+    ORIG_HEAD = "ORIG_HEAD"+    MERGE_HEAD = "MERGE_HEAD"+    MERGE_MSG = "MERGE_MSG" -# Extension name does not start with A-Z => is a required extension.-LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)+    # Sno-specific files:+    MERGE_INDEX = "MERGE_INDEX"+    MERGE_BRANCH = "MERGE_BRANCH" -# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary-# format. (Not the file extension - the filename is simply "index", it has no file extension.)-# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" --# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is-# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension. -# See https://git-scm.com/docs/index-format-LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)---def init_repository(repo_root_path, repo_version):+class SnoConfigKeys:     """-    Initialise a new sno repo. A sno repo is basically a git repo, except --    - git internals are stored in .sno instead of .git-      (.git is a file that contains a reference to .sno, this is allowed by git)-    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md-      but, this only matters once we start committing data. When initialising a repo, these are not yet present.-    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only-      written when data is first imported. When initialising a repo, this is not yet present.-    - there is property in the repo config called sno.repository.version that contains the dataset format version-      number, which is used until the sno.repository.version blob is written.-    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.--    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but-    these are not written by this function, it is up to the caller to configure these as needed.-    See WorkingCopy.write_config()-    """--    repo = pygit2.init_repository(str(repo_root_path.resolve()))-    repo = convert_git_repo_to_sno_repo(repo_root_path)-    write_repo_version_config(repo, repo_version)-    assert is_sno_repo(repo)-    return repo---def convert_git_repo_to_sno_repo(repo_root_path):-    """Given a newly created non-bare git repo, with the following structure:-    repo_root_path/  # also worktree path-        .git/-            HEAD-            ...      # objects, refs, etc-    Converts it to a sno repo with the following structure:-    repo_root_path/  # also worktree path, as before-        .git         # contains "gitdir: .sno"-        .sno/-            HEAD-            index    # Locked using .sno extension-            ...      # etc+    Sno specifig config variables found in sno_repo.config+    (which is read from the file at `sno_repo.gitdir_path / "config"`)     """ -    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()-    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it-    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.+    SNO_REPOSITORY_VERSION = "sno.repository.version"+    SNO_WORKINGCOPY_PATH = "sno.workingcopy.path"+    SNO_WORKINGCOPY_BARE = "sno.workingcopy.bare"  # Older sno repos use this custom variable instead of core.bare+    CORE_BARE = "core.bare"  # Newer sno repos use the standard "core.bare" variable. -    # Move .git to .sno but add a reference at .git so git can find it.-    dot_git_path = repo_root_path / ".git"-    assert dot_git_path.is_dir()-    dot_sno_path = repo_root_path / ".sno"-    assert not dot_sno_path.exists() -    dot_git_path.rename(dot_sno_path)-    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")--    repo = pygit2.Repository(str(repo_root_path.resolve()))-    assert is_sno_repo(repo)+def _append_checksum(data):+    """Appends the 160-bit git-hash to the end of data"""+    return data + pygit2.hash(data).raw -    # Disable git commands that would mess things up:-    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX) -    # Force writing to reflogs.-    repo.config["core.logAllRefUpdates"] = "always"-    return repo+class LockedGitIndex:+    """+    An empty index file, but extended with a required ".sno" extension in the extensions section of the index binary+    format. (Not the file extension - the filename is simply "index", it has no file extension.)+    Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+    in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+    needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.+    """ +    GIT_INDEX_VERSION = 2+    BASE_EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", GIT_INDEX_VERSION, 0) -def is_sno_repo(pygit_repo):-    if pygit_repo is not None:-        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"-        return pygit_repo.is_bare or Path(pygit_repo.path).stem == ".sno"-    return False+    # Extension name does not start with A-Z, therefore is a required extension.+    LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0) +    # See https://git-scm.com/docs/index-format -def get_sno_workdir(pygit_repo):-    # Older sno repos are bare and use repo.path as the "workdir" - that is, where working copies are written --    # Newer ones have an actual workdir.-    return Path(pygit_repo.path) if pygit_repo.is_bare else Path(pygit_repo.workdir)+    LOCKED_EMPTY_GIT_INDEX = _append_checksum(+        BASE_EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION+    )  -@contextlib.contextmanager-def unlocked_git_index(pygit_repo):+class SnoRepo(pygit2.Repository):     """-    A sno repo has an index file containing a required ".sno" extension that git doesn't support, which stops git from-    performing various operations that we want to be only performed by sno - eg `sno checkout` does what the user wants,-    `git checkout` would not do what the user wants, so we disable it in case the user types it out of habit.--    To temporarily re-enable some of these operations from within sno, we can temporarily unlock the index by removing-    the required ".sno" extension.+    A valid pygit2.Repository, since all sno repos are also git repos - but with some added functionality.+    Ensures the git directory structure is one of the two supported by sno - "old + bare" or "new + tidy".+    Prevents worktree-related git commands from working by using a "locked git index".+    Helps set up sno specific config, and adds support for pathlib Paths.     """-    index_path = repo_files.repo_file_path(pygit_repo, repo_files.INDEX)-    if not index_path.exists():-        yield-        return--    _remove_locked_sno_extension(index_path)-    try:-        yield-    finally:-        _add_locked_sno_extension(index_path)---def _remove_locked_sno_extension(index_path):-    index_contents = index_path.read_bytes()-    index_contents = index_contents[:-20]  # Trim off checksum-    if index_contents[-8:] == LOCKED_SNO_EXTENSION:-        index_path.write_bytes(_append_checksum(index_contents[:-8]))---def _add_locked_sno_extension(index_path):-    index_contents = index_path.read_bytes()-    index_contents = index_contents[:-20]  # Trim off checksum-    if index_contents[-8:] != LOCKED_SNO_EXTENSION:-        index_path.write_bytes(_append_checksum(index_contents + LOCKED_SNO_EXTENSION))++    def __init__(self, root_path):+        if isinstance(root_path, Path):+            root_path = str(root_path.resolve())++        try:+            super().__init__(root_path)+        except pygit2.GitError:+            raise NotFound("Not an existing sno repository", exit_code=NO_REPOSITORY)++        self.gitdir_path = Path(self.path).resolve()+        assert self.is_old_bare_repo() or self.is_new_tidy_repo()

 def get_directory_from_url(url):     type=click.Path(exists=False, file_okay=False, writable=True),     required=False, )-def clone(ctx, bare, wc_path, wc_version, do_progress, depth, url, directory):+def clone(ctx, bare, wc_path, do_progress, depth, url, directory):     """ Clone a repository into a new directory """      repo_path = Path(directory or get_directory_from_url(url))+    assert not (repo_path / ".git").exists()

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"+        return pygit_repo.is_bare or Path(pygit_repo.path).stem == ".sno"+    return False+++def get_sno_workdir(pygit_repo):+    # Older sno repos are bare and use repo.path as the "workdir" - that is, where working copies are written -+    # Newer ones have an actual workdir.+    return Path(pygit_repo.path) if pygit_repo.is_bare else Path(pygit_repo.workdir)+++@contextlib.contextmanager+def unlocked_git_index(pygit_repo):

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"+        return pygit_repo.is_bare or Path(pygit_repo.path).stem == ".sno"+    return False+++def get_sno_workdir(pygit_repo):+    # Older sno repos are bare and use repo.path as the "workdir" - that is, where working copies are written -+    # Newer ones have an actual workdir.+    return Path(pygit_repo.path) if pygit_repo.is_bare else Path(pygit_repo.workdir)+++@contextlib.contextmanager+def unlocked_git_index(pygit_repo):+    """+    A sno repo has an index file containing a required ".sno" extension that git doesn't support, which stops git from+    performing various operations that we want to be only performed by sno - eg `sno checkout` does what the user wants,+    `git checkout` would not do what the user wants, so we disable it in case the user types it out of habit.++    To temporarily re-enable some of these operations from within sno, we can temporarily unlock the index by removing+    the required ".sno" extension.+    """+    index_path = repo_files.repo_file_path(pygit_repo, repo_files.INDEX)+    if not index_path.exists():+        yield+        return++    _remove_locked_sno_extension(index_path)+    try:+        yield+    finally:+        _add_locked_sno_extension(index_path)+++def _remove_locked_sno_extension(index_path):+    index_contents = index_path.read_bytes()+    index_contents = index_contents[:-20]  # Trim off checksum+    if index_contents[-8:] == LOCKED_SNO_EXTENSION:

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"+        return pygit_repo.is_bare or Path(pygit_repo.path).stem == ".sno"+    return False+++def get_sno_workdir(pygit_repo):+    # Older sno repos are bare and use repo.path as the "workdir" - that is, where working copies are written -+    # Newer ones have an actual workdir.+    return Path(pygit_repo.path) if pygit_repo.is_bare else Path(pygit_repo.workdir)+++@contextlib.contextmanager+def unlocked_git_index(pygit_repo):+    """+    A sno repo has an index file containing a required ".sno" extension that git doesn't support, which stops git from+    performing various operations that we want to be only performed by sno - eg `sno checkout` does what the user wants,+    `git checkout` would not do what the user wants, so we disable it in case the user types it out of habit.++    To temporarily re-enable some of these operations from within sno, we can temporarily unlock the index by removing+    the required ".sno" extension.+    """+    index_path = repo_files.repo_file_path(pygit_repo, repo_files.INDEX)+    if not index_path.exists():+        yield+        return++    _remove_locked_sno_extension(index_path)+    try:+        yield+    finally:+        _add_locked_sno_extension(index_path)+++def _remove_locked_sno_extension(index_path):+    index_contents = index_path.read_bytes()

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"+        return pygit_repo.is_bare or Path(pygit_repo.path).stem == ".sno"+    return False+++def get_sno_workdir(pygit_repo):+    # Older sno repos are bare and use repo.path as the "workdir" - that is, where working copies are written -+    # Newer ones have an actual workdir.+    return Path(pygit_repo.path) if pygit_repo.is_bare else Path(pygit_repo.workdir)+++@contextlib.contextmanager+def unlocked_git_index(pygit_repo):

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"+        return pygit_repo.is_bare or Path(pygit_repo.path).stem == ".sno"+    return False+++def get_sno_workdir(pygit_repo):+    # Older sno repos are bare and use repo.path as the "workdir" - that is, where working copies are written -+    # Newer ones have an actual workdir.+    return Path(pygit_repo.path) if pygit_repo.is_bare else Path(pygit_repo.workdir)+++@contextlib.contextmanager+def unlocked_git_index(pygit_repo):+    """+    A sno repo has an index file containing a required ".sno" extension that git doesn't support, which stops git from+    performing various operations that we want to be only performed by sno - eg `sno checkout` does what the user wants,+    `git checkout` would not do what the user wants, so we disable it in case the user types it out of habit.++    To temporarily re-enable some of these operations from within sno, we can temporarily unlock the index by removing+    the required ".sno" extension.+    """+    index_path = repo_files.repo_file_path(pygit_repo, repo_files.INDEX)+    if not index_path.exists():+        yield+        return++    _remove_locked_sno_extension(index_path)+    try:+        yield+    finally:+        _add_locked_sno_extension(index_path)+++def _remove_locked_sno_extension(index_path):+    index_contents = index_path.read_bytes()

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)

 def checkout(ctx, branch, force, discard_changes, refish):     reset_wc_if_needed(repo, commit, discard_changes=discard_changes)      repo.set_head(head_ref)-    repo.reset(commit.oid, pygit2.GIT_RESET_SOFT)

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"+        return pygit_repo.is_bare or Path(pygit_repo.path).stem == ".sno"+    return False+++def get_sno_workdir(pygit_repo):+    # Older sno repos are bare and use repo.path as the "workdir" - that is, where working copies are written -+    # Newer ones have an actual workdir.+    return Path(pygit_repo.path) if pygit_repo.is_bare else Path(pygit_repo.workdir)+++@contextlib.contextmanager+def unlocked_git_index(pygit_repo):

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -+# in that sense it is "locked" to git. Various techniques can be used to unlock it if certain git functionality is+# needed - eg marking the repository as bare so it is ignored, or removing the unsupported extension.++# See https://git-scm.com/docs/index-format+LOCKED_EMPTY_GIT_INDEX = _append_checksum(EMPTY_GIT_INDEX + LOCKED_SNO_EXTENSION)+++def init_repository(repo_root_path, repo_version):+    """+    Initialise a new sno repo. A sno repo is basically a git repo, except -+    - git internals are stored in .sno instead of .git+      (.git is a file that contains a reference to .sno, this is allowed by git)+    - datasets are stored in /.sno-dataset/ trees according to a particular dataset format version - see DATASETS_v2.md+      but, this only matters once we start committing data. When initialising a repo, these are not yet present.+    - there is a blob called sno.repository.version that contains the dataset format version number - but, this is only+      written when data is first imported. When initialising a repo, this is not yet present.+    - there is property in the repo config called sno.repository.version that contains the dataset format version+      number, which is used until the sno.repository.version blob is written.+    - the .sno/index file has been extended to stop git messing things up - see LOCKED_EMPTY_GIT_INDEX.++    There can also be properties in the repo config relating to the working copy - named sno.workingcopy.* - but+    these are not written by this function, it is up to the caller to configure these as needed.+    See WorkingCopy.write_config()+    """++    repo = pygit2.init_repository(str(repo_root_path.resolve()))+    repo = convert_git_repo_to_sno_repo(repo_root_path)+    write_repo_version_config(repo, repo_version)+    assert is_sno_repo(repo)+    return repo+++def convert_git_repo_to_sno_repo(repo_root_path):+    """Given a newly created non-bare git repo, with the following structure:+    repo_root_path/  # also worktree path+        .git/+            HEAD+            ...      # objects, refs, etc+    Converts it to a sno repo with the following structure:+    repo_root_path/  # also worktree path, as before+        .git         # contains "gitdir: .sno"+        .sno/+            HEAD+            index    # Locked using .sno extension+            ...      # etc+    """++    # Note: pygit2 can read the .sno directory okay, but it won't create it, so we do it ourselves using Path.rename()+    # Note: We could also call `git init --separate-git-dir=.sno` to crete it but it doesn't work very well - it+    # converts all paths to be absolute, which would mean sno repos wouldn't be renameable.++    # Move .git to .sno but add a reference at .git so git can find it.+    dot_git_path = repo_root_path / ".git"+    assert dot_git_path.is_dir()+    dot_sno_path = repo_root_path / ".sno"+    assert not dot_sno_path.exists()++    dot_git_path.rename(dot_sno_path)+    dot_git_path.write_text("gitdir: .sno\n", encoding="utf-8")++    repo = pygit2.Repository(str(repo_root_path.resolve()))+    assert is_sno_repo(repo)++    # Disable git commands that would mess things up:+    repo_files.write_repo_file(repo, repo_files.INDEX, LOCKED_EMPTY_GIT_INDEX)++    # Force writing to reflogs.+    repo.config["core.logAllRefUpdates"] = "always"+    return repo+++def is_sno_repo(pygit_repo):+    if pygit_repo is not None:+        # Older sno repos were just bare repos, newer sno repos are non-bare git repos that use ".sno" instead of ".git"

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,+# but the .git file, .sno directory, .sno/index file. pygit2 mostly takes care of this for us,+# but since we differ slightly from a standard git repository, there are a few extra things to take care of.+++def _append_checksum(data):+    return data + pygit2.hash(data).raw+++INDEX_VERSION = 2+EMPTY_GIT_INDEX = struct.pack(">4sII", b"DIRC", INDEX_VERSION, 0)++# Extension name does not start with A-Z => is a required extension.+LOCKED_SNO_EXTENSION = struct.pack(">4sI", b".sno", 0)++# An empty index file, but exteneded with a required ".sno" extension in the extensions section of the index binary+# format. (Not the file extension - the filename is simply "index", it has no file extension.)+# Causes all git commands that would involve the index or working copy to fail with "unsupported extension: .sno" -

 def clone(ctx, bare, wc_path, wc_version, do_progress, depth, url, directory):     except subprocess.CalledProcessError as e:         sys.exit(translate_subprocess_exit_code(e.returncode)) -    repo = pygit2.Repository(str(repo_path.resolve()))+    repo = sno_repo.convert_git_repo_to_sno_repo(repo_path)

+import contextlib+import struct+from pathlib import Path++import pygit2++from .repository_version import write_repo_version_config+from . import repo_files+++# Utilities for maintaining file structure of a sno repo - not the versioned controlled blobs,

 def del_repo_cfg(key):             del_repo_cfg("sno.workingcopy.path")             return -        path = path or f"{Path(repo.path).resolve().stem}.gpkg"+        path = path or cls.default_path(repo)         repo_cfg["sno.workingcopy.path"] = str(path)         del_repo_cfg("sno.workingcopy.bare") +    @classmethod+    def default_path(cls, repo):+        workdir = sno_repo.get_sno_workdir(repo)

 def clone(ctx, bare, wc_path, wc_version, do_progress, depth, url, directory):     except subprocess.CalledProcessError as e:         sys.exit(translate_subprocess_exit_code(e.returncode)) -    repo = pygit2.Repository(str(repo_path.resolve()))+    repo = sno_repo.convert_git_repo_to_sno_repo(repo_path) 

 def test_branches(         r = cli_runner.invoke(["checkout", "HEAD~1"])         assert r.exit_code == 0, r -        assert text_branches(cli_runner) == ["* (no branch)", "  master"]+        assert text_branches(cli_runner) == ["* (HEAD detached at 63a9492)", "  master"]

 def init(     write_repo_version_config(repo, repo_version)     WorkingCopy.write_config(repo, wc_path, bare) +    # Enable writing to reflogs+    repo.config["core.logAllRefUpdates"] = "always"

 class RichTreeBuilder:     Conflicts are not detected.     """ -    def __init__(self, repo, initial_root_tree):+    def __init__(self, repo, initial_root_tree, auto_include_version_blobs=True):         """         The repo and an initial root tree which will be updated.         All paths are specified relative to this tree - the root tree at a particular commit is a good choice.

 from .timestamps import tz_offset_to_minutes  +def get_head_tree(repo):+    """Returns the tree at the current repo HEAD."""+    if repo.is_empty:+        return None+    try:+        return repo.head.peel(pygit2.Tree)+    except pygit2.GitError:+        # This happens when the repo is not empty, but the current HEAD has no commits.+        return None+++def get_head_commit(repo):+    """Returns the commit at the current repo HEAD."""

 def apply_meta_diff(self, meta_diff, tree_builder):         if not meta_diff:             return -        conflicts = False+        # Applying diffs works even if there is no tree yet created for the dataset,+        # as is the case when the dataset is first being created right now.+        meta_tree = self.meta_tree if self.tree is not None else () -        meta_tree = self.meta_tree+        conflicts = False

 from .timestamps import tz_offset_to_minutes  +def get_head_tree(repo):+    """Returns the tree at the current repo HEAD."""

 def diff(self, other, ds_filter=UNFILTERED, reverse=False):                 # GIT_DELTA_UNTRACKED                 raise NotImplementedError(f"Delta status: {d.status_char()}") -        # TODO - detect renames by comparing blob ID--        ds_diff["feature"] = feature_diff-        return ds_diff--    def diff_meta(self, other, reverse=False):-        """-        Generates a diff from self -> other, but only for meta items.-        If reverse is true, generates a diff from other -> self.-        """-        if reverse:-            old, new = other, self-        else:-            old, new = self, other--        meta_old = dict(old.meta_items()) if old else {}-        meta_new = dict(new.meta_items()) if new else {}-        return DeltaDiff.diff_dicts(meta_old, meta_new)+        return result -    def _recursive_build_feature_tree(-        self, *, repo, orig_tree, deltas_dict, encode_kwargs, pk_field, geom_column_name-    ):-        """-        Recursively builds a new tree object by applying deltas to the orig_tree.-        """-        conflicts = False-        if orig_tree is None:-            builder = repo.TreeBuilder()-        else:-            builder = repo.TreeBuilder(orig_tree)-        for k, v in deltas_dict.items():-            if isinstance(v, dict):-                orig_subtree = None-                if orig_tree is not None:-                    try:-                        orig_subtree = orig_tree / k-                    except KeyError:-                        pass--                new_subtree, new_conflicts = self._recursive_build_feature_tree(-                    repo=repo,-                    orig_tree=orig_subtree,-                    deltas_dict=v,-                    encode_kwargs=encode_kwargs,-                    pk_field=pk_field,-                    geom_column_name=geom_column_name,-                )-                conflicts = conflicts or new_conflicts-                if new_subtree != orig_subtree:-                    if orig_tree is not None and k in orig_tree:-                        builder.remove(k)-                    builder.insert(k, new_subtree, pygit2.GIT_FILEMODE_TREE)-            else:-                # actually apply blob deltas-                delta = v-                if delta.type == "delete":-                    if (not orig_tree) or k not in orig_tree:-                        conflicts = True-                        pk = delta.old.value[pk_field]-                        click.echo(-                            f"{self.path}: Trying to delete nonexistent feature: {pk}"-                        )-                        continue-                    builder.remove(k)--                elif delta.type == "insert":-                    feature_path, feature_data = self.encode_feature(-                        delta.new.value, **encode_kwargs-                    )-                    if orig_tree and k in orig_tree:-                        conflicts = True-                        pk = delta.new.value[pk_field]-                        click.echo(-                            f"{self.path}: Trying to create feature that already exists: {pk}"-                        )-                        continue-                    blob_id = repo.create_blob(feature_data)-                    builder.insert(k, blob_id, pygit2.GIT_FILEMODE_BLOB)--                elif delta.type == "update":-                    pk = self.decode_path_to_1pk(k)-                    old_pk = delta.old.value[pk_field]-                    if pk == old_pk:-                        # k refers to the *old* object-                        # (it *may* also be the new object if this isn't a rename)-                        if (not orig_tree) or k not in orig_tree:-                            conflicts = True-                            click.echo(-                                f"{self.path}: Trying to update nonexistent feature: {old_pk}"-                            )-                            continue-                        actual_existing_feature = self.get_feature(old_pk)-                        old_feature = delta.old.value-                        if geom_column_name:-                            # FIXME: actually compare the geometries here.-                            # Turns out this is quite hard - geometries are hard to compare sanely.-                            # Even if we add hacks to ignore endianness, WKB seems to vary a bit,-                            # and ogr_geometry.Equal(other) can return false for seemingly-identical geometries...-                            actual_existing_feature.pop(geom_column_name)-                            old_feature = old_feature.copy()-                            old_feature.pop(geom_column_name)-                        if actual_existing_feature != old_feature:-                            conflicts = True-                            click.echo(-                                f"{self.path}: Trying to update already-changed feature: {old_pk}"-                            )-                            continue-                        builder.remove(k)--                    new_pk = delta.new.value[pk_field]-                    if pk == new_pk:-                        # k refers to the *old* object-                        # (it *may* also be the old object if this isn't a rename)-                        new_feature_path, new_feature_data = self.encode_feature(-                            delta.new.value, **encode_kwargs-                        )-                        blob_id = repo.create_blob(new_feature_data)-                        builder.insert(k, blob_id, pygit2.GIT_FILEMODE_BLOB)-        return builder.write(), conflicts--    def write_to_new_tree(self, dataset_diff, repo, *, orig_tree):+    def apply_diff(self, dataset_diff, tree_builder):         """         Given a diff that only affects this dataset, write it to the given treebuilder.-        Blobs will be created in the repo, and referenced in the returned tree, but+        Blobs will be created in the repo, and referenced in the resulting tree, but         no commit is created - this is the responsibility of the caller.         """         # TODO - support multiple primary keys.-        # TODO - support writing new schemas-        pk_field = self.primary_key+        with tree_builder.cd(self.path):+            meta_diff = dataset_diff.get("meta")+            schema = None+            if meta_diff:+                self.apply_meta_diff(meta_diff, tree_builder)++                if "schema.json" in meta_diff and meta_diff["schema.json"].new_value:+                    schema = Schema.from_column_dicts(+                        meta_diff["schema.json"].new_value+                    )++            feature_diff = dataset_diff.get("feature")+            if feature_diff:+                self.apply_feature_diff(feature_diff, tree_builder, schema=schema)++    def apply_meta_diff(self, meta_diff, tree_builder):+        """Applies a meta diff. Not supported until Datasets V2"""+        if not meta_diff:+            return++        raise NotYetImplemented(+            f"Meta changes are not supported for version {self.version}"+        )++    def apply_feature_diff(self, feature_diff, tree_builder, *, schema=None):+        """Applies a feature diff."""++        if not feature_diff:+            return -        conflicts = False         encode_kwargs = {}+        if schema is not None:+            encode_kwargs = {"schema": schema} -        if "meta" in dataset_diff and self.version < 2:-            raise NotYetImplemented(-                f"Meta changes are not supported for version {self.version}"-            )+        geom_column_name = self.geom_column_name -        meta_path = self.full_path(self.META_PATH)-        meta_tree = orig_tree / meta_path-        for delta in dataset_diff.get("meta", {}).values():-            name = delta.key+        conflicts = False+        for delta in feature_diff.values():+            old_key = delta.old_key+            new_key = delta.new_key+            old_path = (+                self.encode_1pk_to_path(old_key, relative=True) if old_key else None+            )+            new_path = (+                self.encode_1pk_to_path(new_key, relative=True) if new_key else None+            ) -            if delta.type == "delete":-                if name not in meta_tree:-                    conflicts = True-                    click.echo(-                        f"{self.path}: Trying to delete nonexistent meta item: {name}"-                    )-                    continue-                meta_tree = git_util.replace_subtree(repo, meta_tree, name, None)+            # Conflict detection+            if delta.type == "delete" and old_path not in self.tree:+                conflicts = True+                click.echo(+                    f"{self.path}: Trying to delete nonexistent feature: {old_key}"+                )+                continue -            elif delta.type == "insert":-                if name in meta_tree:-                    conflicts = True-                    click.echo(-                        f"{self.path}: Trying to create meta item that already exists: {name}"-                    )-                    continue-                if name.endswith(".json"):-                    blob_id = repo.create_blob(json_pack(delta.new.value))-                else:-                    blob_id = repo.create_blob(ensure_bytes(delta.new.value))-                meta_tree = git_util.replace_subtree(repo, meta_tree, name, blob_id)--            elif delta.type == "update":-                if name not in meta_tree:-                    conflicts = True-                    click.echo(-                        f"{self.path}: Trying to update nonexistent meta item: {name}"-                    )-                    continue+            if delta.type == "insert" and new_path in self.tree:+                conflicts = True+                click.echo(+                    f"{self.path}: Trying to create feature that already exists: {new_key}"+                )+                continue -                if self.get_meta_item(name) != delta.old.value:-                    conflicts = True-                    click.echo(-                        f"{self.path}: Trying to update already-changed meta item: {name}"-                    )-                    continue-                meta_tree = git_util.replace_subtree(repo, meta_tree, name, None)-                if name == "schema.json":-                    old_schema = Schema.from_column_dicts(delta.old.value)-                    new_schema = Schema.from_column_dicts(delta.new.value)-                    if not old_schema.is_pk_compatible(new_schema):-                        raise NotYetImplemented(-                            "Schema changes that involve primary key changes are not yet supported"-                        )--                    encode_kwargs = {"schema": new_schema}-                    to_write = []-                    key, value = self.encode_schema(new_schema)-                    to_write.append((key[len(meta_path) :].lstrip('/'), value))-                    key, value = self.encode_legend(new_schema.legend)-                    to_write.append((key[len(meta_path) :].lstrip('/'), value))-                elif name.endswith(".json"):-                    to_write = [(name, json_pack(delta.new.value))]-                else:-                    to_write = [(name, ensure_bytes(delta.new.value))]-                for path, data in to_write:-                    blob_id = repo.create_blob(data)-                    meta_tree = git_util.replace_subtree(repo, meta_tree, path, blob_id)+            if delta.type == "update" and old_path not in self.tree:+                conflicts = True+                click.echo(+                    f"{self.path}: Trying to update nonexistent feature: {old_key}"+                )+                continue -        orig_tree = git_util.replace_subtree(repo, orig_tree, meta_path, meta_tree)+            if delta.type == "update" and not self._features_equal(+                self.get_feature(old_key), delta.old_value, geom_column_name+            ):+                conflicts = True+                click.echo(+                    f"{self.path}: Trying to update already-changed feature: {old_key}"+                )+                continue -        geom_column_name = self.geom_column_name-        deltas_by_directory = {}-        for delta in dataset_diff.get("feature", {}).values():-            if delta.type == "delete":-                pks = {delta.old.value[pk_field]}-            elif delta.type == "insert":-                pks = {delta.new.value[pk_field]}-            elif delta.type == "update":-                pks = {delta.old.value[pk_field], delta.new.value[pk_field]}--            for pk in pks:-                feature_path = self.encode_1pk_to_path(pk)-                pieces = feature_path.rsplit('/')-                dir_ = deltas_by_directory-                for piece in pieces[:-1]:-                    dir_ = dir_.setdefault(piece, {})-                dir_[pieces[-1]] = delta--        new_tree, conflicts = self._recursive_build_feature_tree(-            orig_tree=orig_tree,-            repo=repo,-            deltas_dict=deltas_by_directory,-            encode_kwargs=encode_kwargs,-            pk_field=pk_field,-            geom_column_name=geom_column_name,-        )+            # Actually write the feature diff:+            if old_path and old_path != new_path:+                tree_builder.remove(old_path)+            if delta.new_value:+                path, data = self.encode_feature(+                    delta.new.value, relative=True, **encode_kwargs+                )+                tree_builder.insert(path, data)          if conflicts:             raise InvalidOperation(                 "Patch does not apply", exit_code=PATCH_DOES_NOT_APPLY,             )-        return new_tree++    def _features_equal(self, lhs, rhs, geom_column_name):+        # FIXME: actually compare the geometries here.+        # Turns out this is quite hard - geometries are hard to compare sanely.+        # Even if we add hacks to ignore endianness, WKB seems to vary a bit,

+import contextlib++import pygit2++EMPTY_TREE_ID = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'+++class RichTreeBuilder:+    """+    Like a pygit2.TreeBuilder, but more powerful - the client can buffer any number of writes to any paths+    whereas a pygit2.TreeBuilder only lets you modify one tree at a time.+    Also a bit like a pygit2.Index, but much more performant since it uses dicts instead of sorted vectors.+    Conflicts are not detected.+    """++    def __init__(self, repo, initial_root_tree):+        """+        The repo and an initial root tree which will be updated.+        All paths are specified relative to this tree - the root tree at a particular commit is a good choice.+        """+        self.repo = repo+        self.root_tree = initial_root_tree++        self.root_dict = {}+        self.cur_path = []+        self.path_stack = []++    def _resolve_path(self, path):+        """+        Resolve the given a path relative to the current path.+        The given path can be a string like "a/b/c" or a list like ["a", "b", "c"].+        """+        if isinstance(path, str):

+import contextlib++import pygit2++EMPTY_TREE_ID = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'+++class RichTreeBuilder:+    """+    Like a pygit2.TreeBuilder, but more powerful - the client can buffer any number of writes to any paths+    whereas a pygit2.TreeBuilder only lets you modify one tree at a time.+    Also a bit like a pygit2.Index, but much more performant since it uses dicts instead of sorted vectors.+    Conflicts are not detected.+    """++    def __init__(self, repo, initial_root_tree):+        """+        The repo and an initial root tree which will be updated.+        All paths are specified relative to this tree - the root tree at a particular commit is a good choice.+        """+        self.repo = repo+        self.root_tree = initial_root_tree++        self.root_dict = {}+        self.cur_path = []+        self.path_stack = []++    def _resolve_path(self, path):+        """+        Resolve the given a path relative to the current path.+        The given path can be a string like "a/b/c" or a list like ["a", "b", "c"].+        """+        if isinstance(path, str):+            if path.startswith("/"):+                raise RuntimeError(+                    "RichTreeBuilder.cd() does not support absolute paths"+                )+            path = path.strip("/").split("/")+        return self.cur_path + path++    @contextlib.contextmanager+    def cd(self, path):+        """+        Change the current directory used to resolve paths by the given relative path.+        Returns a context manager - when the context manager is closed, the original current directory is restored.++        Example:+        >>> with rich_tree_builder.cd("a/b/c/.sno-dataset"):+        >>>    # Make edits inside a/b/c/.sno-dataset:+        >>>    rich_tree_builder.remove("meta/title")+        >>> # Context manager closes, current path is reset to the default.+        """+        path = self._resolve_path(path)+        self._pushd()

+import contextlib++import pygit2++EMPTY_TREE_ID = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'

+import contextlib++import pygit2++EMPTY_TREE_ID = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'+++class RichTreeBuilder:+    """+    Like a pygit2.TreeBuilder, but more powerful - the client can buffer any number of writes to any paths+    whereas a pygit2.TreeBuilder only lets you modify one tree at a time.+    Also a bit like a pygit2.Index, but much more performant since it uses dicts instead of sorted vectors.+    Conflicts are not detected.+    """++    def __init__(self, repo, initial_root_tree):+        """+        The repo and an initial root tree which will be updated.+        All paths are specified relative to this tree - the root tree at a particular commit is a good choice.+        """+        self.repo = repo+        self.root_tree = initial_root_tree++        self.root_dict = {}+        self.cur_path = []+        self.path_stack = []++    def _resolve_path(self, path):+        """+        Resolve the given a path relative to the current path.+        The given path can be a string like "a/b/c" or a list like ["a", "b", "c"].+        """+        if isinstance(path, str):+            if path.startswith("/"):+                raise RuntimeError(+                    "RichTreeBuilder.cd() does not support absolute paths"+                )+            path = path.strip("/").split("/")+        return self.cur_path + path++    @contextlib.contextmanager+    def cd(self, path):

 jobs:             os: macos-latest             package-formats: pkg             services: {}-    if: "startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/master' || !contains(github.event.head_commit.message, '[ci only windows]')"+    # We want to run on external PRs, but not on our own internal PRs as they'll be run+    # by the push to the branch.+    # https://github.community/t/duplicate-checks-on-push-and-pull-request-simultaneous-event/18012/7

 jobs:   windows:     name: Windows     runs-on: windows-2016-    if: "startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/master' || !contains(github.event.head_commit.message, '[ci only posix]')"+    # We want to run on external PRs, but not on our own internal PRs as they'll be run+    # by the push to the branch.+    # https://github.community/t/duplicate-checks-on-push-and-pull-request-simultaneous-event/18012/7

 def _gpkg_srs_id(v2_obj):  def wkt_to_gpkg_spatial_ref_sys(wkt):     """Given a WKT crs definition, generate a gpkg_spatial_ref_sys meta item."""-    # TODO: Better support for custom WKT. https://github.com/koordinates/sno/issues/148     spatial_ref = SpatialReference(wkt)-    spatial_ref.AutoIdentifyEPSG()

 def _gpkg_srs_id(v2_obj):  def wkt_to_gpkg_spatial_ref_sys(wkt):     """Given a WKT crs definition, generate a gpkg_spatial_ref_sys meta item."""-    # TODO: Better support for custom WKT. https://github.com/koordinates/sno/issues/148     spatial_ref = SpatialReference(wkt)-    spatial_ref.AutoIdentifyEPSG()