pygit2 1.13.2__tar.gz → 1.13.3__tar.gz

{pygit2-1.13.2 → pygit2-1.13.3}/AUTHORS.rst

@@ -4,41 +4,42 @@ Authors::
   Carlos Martín Nieto
   Nico von Geyso
   Sviatoslav Sydorenko
-  Robert Coup
+  Iliyas Jorio
   Matthias Bartelmeß
+  Robert Coup
   W. Trevor King
-  Iliyas Jorio
   Drew DeVault
   Dave Borowitz
   Brandon Milton
   Daniel Rodríguez Troitiño
+  Peter Rowlands
   Richo Healey
   Christian Boos
   Julien Miotte
   Nick Hynes
   Richard Möhn
   Xu Tao
-  Jose Plana
   Matthew Duggan
   Matthew Gamble
   Jeremy Westwood
+  Jose Plana
   Martin Lenders
-  Petr Hosek
   Sriram Raghu
   Victor Garcia
-  Xavier Delannoy
   Yonggang Luo
   Patrick Steinhardt
+  Petr Hosek
   Tamir Bahar
   Valentin Haenel
+  Xavier Delannoy
   Michael Jones
   Saugat Pachhai
   Bernardo Heynemann
-  Brodie Rao
   John Szakmeister
   Nabijacz Leweli
   Simon Cozens
   Vlad Temian
+  Brodie Rao
   Chad Dombrova
   Lukas Fleischer
   Mathias Leppich
@@ -49,7 +50,6 @@ Authors::
   Dan Sully
   David Versmisse
   Mikhail Yushkovskiy
-  Peter Rowlands
   Robin Stocker
   Rohit Sanjay
   Rémi Duraffort
@@ -119,6 +119,7 @@ Authors::
   Vicent Marti
   Zbigniew Jędrzejewski-Szmek
   Zoran Zaric
+  nikitalita
   Adam Gausmann
   Adam Spiers
   Albin Söderström

{pygit2-1.13.2 → pygit2-1.13.3}/CHANGELOG.rst

@@ -1,3 +1,25 @@
+1.13.3 (2023-11-21)
+-------------------------
+
+- New API for filters in Python
+  `#1237 <https://github.com/libgit2/pygit2/pull/1237>`_
+  `#1244 <https://github.com/libgit2/pygit2/pull/1244>`_
+
+- Shallow repositories: New ``depth`` optional argument for
+  ``clone_repository(...)`` and ``Remote.fetch(...)``
+  `#1245 <https://github.com/libgit2/pygit2/pull/1245>`_
+  `#1246 <https://github.com/libgit2/pygit2/pull/1246>`_
+
+- New submodule ``init(...)``, ``update(...)`` and ``reload(...)`` functions
+  `#1248 <https://github.com/libgit2/pygit2/pull/1248>`_
+
+- Release GIL in ``Walker.__next__``
+  `#1249 <https://github.com/libgit2/pygit2/pull/1249>`_
+
+- Type hints for submodule functions in ``Repository``
+  `#1247 <https://github.com/libgit2/pygit2/pull/1247>`_
+
+
 1.13.2 (2023-10-30)
 -------------------------
 

{pygit2-1.13.2 → pygit2-1.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pygit2
-Version: 1.13.2
+Version: 1.13.3
 Summary: Python bindings for libgit2.
 Home-page: https://github.com/libgit2/pygit2
 Maintainer: J. David Ibáñez

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/__init__.py

@@ -31,12 +31,15 @@ from ._pygit2 import *
 
 # High level API
 from .blame import Blame, BlameHunk
+from .blob import BlobIO
 from .callbacks import git_clone_options, git_fetch_options, get_credentials
 from .callbacks import Payload, RemoteCallbacks, CheckoutCallbacks, StashApplyCallbacks
 from .config import Config
 from .credentials import *
 from .errors import check_error, Passthrough
+from .enums import SubmoduleIgnore, SubmoduleStatus
 from .ffi import ffi, C
+from .filter import Filter
 from .index import Index, IndexEntry
 from .remote import Remote
 from .repository import Repository
@@ -92,6 +95,8 @@ GIT_ATTR_CHECK_FILE_THEN_INDEX = C.GIT_ATTR_CHECK_FILE_THEN_INDEX
 GIT_ATTR_CHECK_INDEX_THEN_FILE = C.GIT_ATTR_CHECK_INDEX_THEN_FILE
 GIT_ATTR_CHECK_INDEX_ONLY      = C.GIT_ATTR_CHECK_INDEX_ONLY
 GIT_ATTR_CHECK_NO_SYSTEM       = C.GIT_ATTR_CHECK_NO_SYSTEM
+GIT_ATTR_CHECK_INCLUDE_HEAD    = C.GIT_ATTR_CHECK_INCLUDE_HEAD
+GIT_ATTR_CHECK_INCLUDE_COMMIT  = C.GIT_ATTR_CHECK_INCLUDE_COMMIT
 
 # GIT_FETCH_PRUNE
 GIT_FETCH_PRUNE_UNSPECIFIED    = C.GIT_FETCH_PRUNE_UNSPECIFIED
@@ -197,7 +202,7 @@ def init_repository(path, bare=False,
 
 def clone_repository(
         url, path, bare=False, repository=None, remote=None,
-        checkout_branch=None, callbacks=None):
+        checkout_branch=None, callbacks=None, depth=0):
     """
     Clones a new Git repository from *url* in the given *path*.
 
@@ -231,6 +236,12 @@ def clone_repository(
 
         The callbacks should be an object which inherits from
         `pyclass:RemoteCallbacks`.
+    depth : int
+        Number of commits to clone.
+
+        If greater than 0, creates a shallow clone with a history truncated to
+        the specified number of commits.
+        The default is 0 (full commit history).
     """
 
     if callbacks is None:
@@ -244,6 +255,7 @@ def clone_repository(
     with git_clone_options(payload):
         opts = payload.clone_options
         opts.bare = bare
+        opts.fetch_opts.depth = depth
 
         if checkout_branch:
             checkout_branch_ref = ffi.new('char []', to_bytes(checkout_branch))

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/_build.py

@@ -34,7 +34,7 @@ from pathlib import Path
 #
 # The version number of pygit2
 #
-__version__ = '1.13.2'
+__version__ = '1.13.3'
 
 
 #

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/_pygit2.pyi

@@ -495,7 +495,6 @@ class Repository:
     def expand_id(self, hex: str) -> Oid: ...
     def free(self) -> None: ...
     def git_object_lookup_prefix(self, oid: _OidArg) -> Object: ...
-    def init_submodules(self, submodules: Optional[list[Submodule]] = None, overwrite = False) -> None: ...
     def list_worktrees(self) -> list[str]: ...
     def listall_branches(self, flag: int = GIT_BRANCH_LOCAL) -> list[str]: ...
     def listall_stashes(self) -> list[Stash]: ...

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/_run.py

@@ -54,8 +54,8 @@ else:
 # Order matters
 h_files = [
     'types.h',
-    'attr.h',
     'oid.h',
+    'attr.h',
     'blame.h',
     'buffer.h',
     'strarray.h',
@@ -91,14 +91,15 @@ for h_file in h_files:
 
 C_HEADER_SRC = '\n'.join(h_source)
 
+C_PREAMBLE = """\
+#include <git2.h>
+#include <git2/sys/repository.h>
+"""
+
 # ffi
 _, libgit2_kw = get_libgit2_paths()
 ffi = FFI()
-ffi.set_source(
-    "pygit2._libgit2",
-    "#include <git2.h>", # preamble
-    **libgit2_kw
-)
+ffi.set_source("pygit2._libgit2", C_PREAMBLE, **libgit2_kw)
 ffi.cdef(C_HEADER_SRC)
 
 

pygit2-1.13.3/pygit2/blob.py

@@ -0,0 +1,154 @@
+import io
+import threading
+import time
+from contextlib import AbstractContextManager
+from typing import Optional
+from queue import Queue
+
+from ._pygit2 import GIT_BLOB_FILTER_CHECK_FOR_BINARY, Blob, Oid
+
+
+class _BlobIO(io.RawIOBase):
+    """Low-level wrapper for streaming blob content.
+
+    The underlying libgit2 git_writestream filter chain will be run
+    in a separate thread. The GIL will be released while running
+    libgit2 filtering.
+    """
+
+    def __init__(
+        self,
+        blob: Blob,
+        as_path: Optional[str] = None,
+        flags: int = GIT_BLOB_FILTER_CHECK_FOR_BINARY,
+        commit_id: Optional[Oid] = None,
+    ):
+        super().__init__()
+        self._blob = blob
+        self._queue = Queue(maxsize=1)
+        self._ready = threading.Event()
+        self._writer_closed = threading.Event()
+        self._chunk: Optional[bytes] = None
+        self._thread = threading.Thread(
+            target=self._blob._write_to_queue,
+            args=(self._queue, self._ready, self._writer_closed),
+            kwargs={
+                "as_path": as_path,
+                "flags": flags,
+                "commit_id": commit_id,
+            },
+            daemon=True,
+        )
+        self._thread.start()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def isatty():
+        return False
+
+    def readable(self):
+        return True
+
+    def writable(self):
+        return False
+
+    def seekable(self):
+        return False
+
+    def readinto(self, b, /):
+        try:
+            while self._chunk is None:
+                self._ready.wait()
+                if self._queue.empty():
+                    if self._writer_closed.is_set():
+                        # EOF
+                        return 0
+                    self._ready.clear()
+                    time.sleep(0)
+                    continue
+                chunk = self._queue.get()
+                if chunk:
+                    self._chunk = chunk
+
+            if len(self._chunk) <= len(b):
+                bytes_written = len(self._chunk)
+                b[:bytes_written] = self._chunk
+                self._chunk = None
+                return bytes_written
+            bytes_written = len(b)
+            b[:] = self._chunk[:bytes_written]
+            self._chunk = self._chunk[bytes_written:]
+            return bytes_written
+        except KeyboardInterrupt:
+            return 0
+
+    def close(self):
+        try:
+            self._ready.wait()
+            self._writer_closed.wait()
+            while self._queue is not None and not self._queue.empty():
+                self._queue.get()
+            self._thread.join()
+        except KeyboardInterrupt:
+            pass
+        self._queue = None
+
+
+class BlobIO(io.BufferedReader, AbstractContextManager):
+    """Read-only wrapper for streaming blob content.
+
+    Supports reading both raw and filtered blob content.
+    Implements io.BufferedReader.
+
+    Example:
+
+        >>> with BlobIO(blob) as f:
+        ...     while True:
+        ...         # Read blob data in 1KB chunks until EOF is reached
+        ...         chunk = f.read(1024)
+        ...         if not chunk:
+        ...             break
+
+    By default, `BlobIO` will stream the raw contents of the blob, but it
+    can also be used to stream filtered content (i.e. to read the content
+    after applying filters which would be used when checking out the blob
+    to the working directory).
+
+    Example:
+
+        >>> with BlobIO(blob, as_path='my_file.ext') as f:
+        ...     # Read the filtered content which would be returned upon
+        ...     # running 'git checkout -- my_file.txt'
+        ...     filtered_data = f.read()
+    """
+
+    def __init__(
+        self,
+        blob: Blob,
+        as_path: Optional[str] = None,
+        flags: int = GIT_BLOB_FILTER_CHECK_FOR_BINARY,
+        commit_id: Optional[Oid] = None,
+    ):
+        """Wrap the specified blob.
+
+        Parameters:
+            blob: The blob to wrap.
+            as_path: Filter the contents of the blob as if it had the specified
+                path. If `as_path` is None, the raw contents of the blob will
+                be read.
+            flags: GIT_BLOB_FILTER_* bitflags (only applicable when `as_path`
+                is set).
+            commit_oid: Commit to load attributes from when
+                GIT_BLOB_FILTER_ATTRIBUTES_FROM_COMMIT is specified in `flags`
+                (only applicable when `as_path` is set).
+        """
+        raw = _BlobIO(blob, as_path=as_path, flags=flags, commit_id=commit_id)
+        super().__init__(raw)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
+io.RawIOBase.register(_BlobIO)
+io.BufferedIOBase.register(BlobIO)

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/decl/attr.h

@@ -1,7 +1,11 @@
 #define GIT_ATTR_CHECK_FILE_THEN_INDEX	0
 #define GIT_ATTR_CHECK_INDEX_THEN_FILE	1
 #define GIT_ATTR_CHECK_INDEX_ONLY		2
-#define GIT_ATTR_CHECK_NO_SYSTEM		4
+#define GIT_ATTR_CHECK_NO_SYSTEM        4
+#define GIT_ATTR_CHECK_INCLUDE_HEAD     8
+#define GIT_ATTR_CHECK_INCLUDE_COMMIT   16
+
+#define GIT_ATTR_OPTIONS_VERSION ...
 
 typedef enum {
 	GIT_ATTR_VALUE_UNSPECIFIED = 0, /**< The attribute has been left unspecified */
@@ -10,10 +14,17 @@ typedef enum {
 	GIT_ATTR_VALUE_STRING  /**< This attribute has a value */
 } git_attr_value_t;
 
-int git_attr_get(
+typedef struct {
+	unsigned int version;
+	unsigned int flags;
+	git_oid *commit_id;
+	git_oid attr_commit_id;
+} git_attr_options;
+
+int git_attr_get_ext(
 	const char **value_out,
 	git_repository *repo,
-	uint32_t flags,
+	git_attr_options *opts,
 	const char *path,
 	const char *name);
 

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/decl/repository.h

@@ -87,3 +87,6 @@ int git_repository_ident(const char **name, const char **email, const git_reposi
 int git_repository_set_ident(git_repository *repo, const char *name, const char *email);
 int git_repository_index(git_index **out, git_repository *repo);
 git_repository_state_t git_repository_state(git_repository *repo);
+
+int git_repository_submodule_cache_all(git_repository *repo);
+int git_repository_submodule_cache_clear(git_repository *repo);

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/decl/submodule.h

@@ -30,12 +30,14 @@ int git_submodule_lookup(
 	const char *name);
 
 void git_submodule_free(git_submodule *submodule);
-int git_submodule_open(
-	git_repository **repo,
-	git_submodule *submodule);
+int git_submodule_open(git_repository **repo, git_submodule *submodule);
+int git_submodule_init(git_submodule *submodule, int overwrite);
+int git_submodule_reload(git_submodule *submodule, int force);
 
 const char * git_submodule_name(git_submodule *submodule);
 const char * git_submodule_path(git_submodule *submodule);
 const char * git_submodule_url(git_submodule *submodule);
 const char * git_submodule_branch(git_submodule *submodule);
 const git_oid * git_submodule_head_id(git_submodule *submodule);
+
+int git_submodule_status(unsigned int *status, git_repository *repo, const char *name, git_submodule_ignore_t ignore);

pygit2-1.13.3/pygit2/enums.py

@@ -0,0 +1,64 @@
+from enum import IntEnum, IntFlag
+
+from . import _pygit2
+
+
+class SubmoduleIgnore(IntEnum):
+    UNSPECIFIED = _pygit2.GIT_SUBMODULE_IGNORE_UNSPECIFIED
+    "use the submodule's configuration"
+
+    NONE = _pygit2.GIT_SUBMODULE_IGNORE_NONE
+    "any change or untracked == dirty"
+
+    UNTRACKED = _pygit2.GIT_SUBMODULE_IGNORE_UNTRACKED
+    "dirty if tracked files change"
+
+    DIRTY = _pygit2.GIT_SUBMODULE_IGNORE_DIRTY
+    "only dirty if HEAD moved"
+
+    ALL = _pygit2.GIT_SUBMODULE_IGNORE_ALL
+    "never dirty"
+
+
+class SubmoduleStatus(IntFlag):
+    IN_HEAD = _pygit2.GIT_SUBMODULE_STATUS_IN_HEAD
+    "superproject head contains submodule"
+
+    IN_INDEX = _pygit2.GIT_SUBMODULE_STATUS_IN_INDEX
+    "superproject index contains submodule"
+
+    IN_CONFIG = _pygit2.GIT_SUBMODULE_STATUS_IN_CONFIG
+    "superproject gitmodules has submodule"
+
+    IN_WD = _pygit2.GIT_SUBMODULE_STATUS_IN_WD
+    "superproject workdir has submodule"
+
+    INDEX_ADDED = _pygit2.GIT_SUBMODULE_STATUS_INDEX_ADDED
+    "in index, not in head (flag available if ignore is not ALL)"
+
+    INDEX_DELETED = _pygit2.GIT_SUBMODULE_STATUS_INDEX_DELETED
+    "in head, not in index (flag available if ignore is not ALL)"
+
+    INDEX_MODIFIED = _pygit2.GIT_SUBMODULE_STATUS_INDEX_MODIFIED
+    "index and head don't match (flag available if ignore is not ALL)"
+
+    WD_UNINITIALIZED = _pygit2.GIT_SUBMODULE_STATUS_WD_UNINITIALIZED
+    "workdir contains empty repository (flag available if ignore is not ALL)"
+
+    WD_ADDED = _pygit2.GIT_SUBMODULE_STATUS_WD_ADDED
+    "in workdir, not index (flag available if ignore is not ALL)"
+
+    WD_DELETED = _pygit2.GIT_SUBMODULE_STATUS_WD_DELETED
+    "in index, not workdir (flag available if ignore is not ALL)"
+
+    WD_MODIFIED = _pygit2.GIT_SUBMODULE_STATUS_WD_MODIFIED
+    "index and workdir head don't match (flag available if ignore is not ALL)"
+
+    WD_INDEX_MODIFIED = _pygit2.GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED
+    "submodule workdir index is dirty (flag available if ignore is NONE or UNTRACKED)"
+
+    WD_WD_MODIFIED = _pygit2.GIT_SUBMODULE_STATUS_WD_WD_MODIFIED
+    "submodule workdir has modified files (flag available if ignore is NONE or UNTRACKED)"
+
+    WD_UNTRACKED = _pygit2.GIT_SUBMODULE_STATUS_WD_UNTRACKED
+    "submodule workdir contains untracked files (flag available if ignore is NONE)"

pygit2-1.13.3/pygit2/filter.py

@@ -0,0 +1,115 @@
+# Copyright 2010-2023 The pygit2 contributors
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2,
+# as published by the Free Software Foundation.
+#
+# In addition to the permissions in the GNU General Public License,
+# the authors give you unlimited permission to link the compiled
+# version of this file into combinations with other programs,
+# and to distribute those combinations without any restriction
+# coming from the use of this file.  (The General Public License
+# restrictions do apply in other respects; for example, they cover
+# modification of the file, and distribution when not linked into
+# a combined executable.)
+#
+# This file is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING.  If not, write to
+# the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+# Boston, MA 02110-1301, USA.
+
+from typing import Callable, List, Optional
+
+from ._pygit2 import FilterSource
+
+
+class Filter:
+    """
+    Base filter class to be used with libgit2 filters.
+
+    Inherit from this class and override the `check()`, `write()` and `close()`
+    methods to define a filter which can then be registered via
+    `pygit2.filter_register()`.
+
+    A new Filter instance will be instantiated for each stream which needs to
+    be filtered. For each stream, filter methods will be called in this order:
+
+        - `check()`
+        - `write()` (may be called multiple times)
+        - `close()`
+
+    Filtered output data should be written to the next filter in the chain
+    during `write()` and `close()` via the `write_next` method. All output data
+    must be written to the next filter before returning from `close()`.
+
+    If a filter is dependent on reading the complete input data stream, the
+    filter should only write output data in `close()`.
+    """
+
+    #: Space-separated string list of attributes to be used in `check()`
+    attributes: str = ""
+
+    @classmethod
+    def nattrs(cls) -> int:
+        return len(cls.attributes.split())
+
+    def check(self, src: FilterSource, attr_values: List[Optional[str]]):
+        """
+        Check whether this filter should be applied to the given source.
+
+        `check` will be called once per stream.
+
+        If `Passthrough` is raised, the filter will not be applied.
+
+        Parameters:
+
+        src: The source of the filtered blob.
+
+        attr_values: The values of each attribute for the blob being filtered.
+            `attr_values` will be a sorted list containing attributes in the
+            order they were defined in ``cls.attributes``.
+        """
+
+    def write(
+        self,
+        data: bytes,
+        src: FilterSource,
+        write_next: Callable[[bytes], None]
+    ):
+        """
+        Write input `data` to this filter.
+
+        `write()` may be called multiple times per stream.
+
+        Parameters:
+
+        data: Input data.
+
+        src: The source of the filtered blob.
+
+        write_next: The ``write()`` method of the next filter in the chain.
+            Filtered output data should be written to `write_next` whenever it is
+            available.
+        """
+        write_next(data)
+
+    def close(
+        self,
+        write_next: Callable[[bytes], None]
+    ):
+        """
+        Close this filter.
+
+        `close()` will be called once per stream whenever all writes() to this
+        stream have been completed.
+
+        Parameters:
+            write_next: The ``write()`` method of the next filter in the chain.
+                Any remaining filtered output data must be written to
+                `write_next` before returning.
+        """

{pygit2-1.13.2 → pygit2-1.13.3}/pygit2/remote.py

@@ -111,7 +111,7 @@ class Remote:
                                        ffi.NULL)
             payload.check_error(err)
 
-    def fetch(self, refspecs=None, message=None, callbacks=None, prune=C.GIT_FETCH_PRUNE_UNSPECIFIED, proxy=None):
+    def fetch(self, refspecs=None, message=None, callbacks=None, prune=C.GIT_FETCH_PRUNE_UNSPECIFIED, proxy=None, depth=0):
         """Perform a fetch against this remote. Returns a <TransferProgress>
         object.
 
@@ -130,10 +130,18 @@ class Remote:
             * `None` (the default) to disable proxy usage
             * `True` to enable automatic proxy detection
             * an url to a proxy (`http://proxy.example.org:3128/`)
+
+        depth : int
+            Number of commits from the tip of each remote branch history to fetch.
+
+            If non-zero, the number of commits from the tip of each remote
+            branch history to fetch. If zero, all history is fetched.
+            The default is 0 (all history is fetched).
         """
         with git_fetch_options(callbacks) as payload:
             opts = payload.fetch_options
             opts.prune = prune
+            opts.depth = depth
             self.__set_proxy(opts.proxy_opts, proxy)
             with StrArray(refspecs) as arr:
                 err = C.git_remote_fetch(self._remote, arr, opts, to_bytes(message))