Add files using upload-large-folder tool

venv/lib/python3.10/site-packages/git/index/__init__.py

@@ -0,0 +1,16 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Initialize the index package."""
+
+__all__ = [
+    "BaseIndexEntry",
+    "BlobFilter",
+    "CheckoutError",
+    "IndexEntry",
+    "IndexFile",
+    "StageType",
+]
+
+from .base import CheckoutError, IndexFile
+from .typ import BaseIndexEntry, BlobFilter, IndexEntry, StageType

venv/lib/python3.10/site-packages/git/index/base.py

@@ -0,0 +1,1518 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Module containing :class:`IndexFile`, an Index implementation facilitating all kinds
+of index manipulations such as querying and merging."""
+
+__all__ = ["IndexFile", "CheckoutError", "StageType"]
+
+import contextlib
+import datetime
+import glob
+from io import BytesIO
+import os
+import os.path as osp
+from stat import S_ISLNK
+import subprocess
+import sys
+import tempfile
+
+from gitdb.base import IStream
+from gitdb.db import MemoryDB
+
+from git.compat import defenc, force_bytes
+import git.diff as git_diff
+from git.exc import CheckoutError, GitCommandError, GitError, InvalidGitRepositoryError
+from git.objects import Blob, Commit, Object, Submodule, Tree
+from git.objects.util import Serializable
+from git.util import (
+    Actor,
+    LazyMixin,
+    LockedFD,
+    join_path_native,
+    file_contents_ro,
+    to_native_path_linux,
+    unbare_repo,
+    to_bin_sha,
+)
+
+from .fun import (
+    S_IFGITLINK,
+    aggressive_tree_merge,
+    entry_key,
+    read_cache,
+    run_commit_hook,
+    stat_mode_to_index_mode,
+    write_cache,
+    write_tree_from_cache,
+)
+from .typ import BaseIndexEntry, IndexEntry, StageType
+from .util import TemporaryFileSwap, post_clear_cache, default_index, git_working_dir
+
+# typing -----------------------------------------------------------------------------
+
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Dict,
+    Generator,
+    IO,
+    Iterable,
+    Iterator,
+    List,
+    NoReturn,
+    Sequence,
+    TYPE_CHECKING,
+    Tuple,
+    Union,
+)
+
+from git.types import Literal, PathLike
+
+if TYPE_CHECKING:
+    from subprocess import Popen
+
+    from git.refs.reference import Reference
+    from git.repo import Repo
+
+
+Treeish = Union[Tree, Commit, str, bytes]
+
+# ------------------------------------------------------------------------------------
+
+
+@contextlib.contextmanager
+def _named_temporary_file_for_subprocess(directory: PathLike) -> Generator[str, None, None]:
+    """Create a named temporary file git subprocesses can open, deleting it afterward.
+
+    :param directory:
+        The directory in which the file is created.
+
+    :return:
+        A context manager object that creates the file and provides its name on entry,
+        and deletes it on exit.
+    """
+    if sys.platform == "win32":
+        fd, name = tempfile.mkstemp(dir=directory)
+        os.close(fd)
+        try:
+            yield name
+        finally:
+            os.remove(name)
+    else:
+        with tempfile.NamedTemporaryFile(dir=directory) as ctx:
+            yield ctx.name
+
+
+class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
+    """An Index that can be manipulated using a native implementation in order to save
+    git command function calls wherever possible.
+
+    This provides custom merging facilities allowing to merge without actually changing
+    your index or your working tree. This way you can perform your own test merges based
+    on the index only without having to deal with the working copy. This is useful in
+    case of partial working trees.
+
+    Entries:
+
+        The index contains an entries dict whose keys are tuples of type
+        :class:`~git.index.typ.IndexEntry` to facilitate access.
+
+        You may read the entries dict or manipulate it using IndexEntry instance, i.e.::
+
+            index.entries[index.entry_key(index_entry_instance)] = index_entry_instance
+
+    Make sure you use :meth:`index.write() <write>` once you are done manipulating the
+    index directly before operating on it using the git command.
+    """
+
+    __slots__ = ("repo", "version", "entries", "_extension_data", "_file_path")
+
+    _VERSION = 2
+    """The latest version we support."""
+
+    S_IFGITLINK = S_IFGITLINK
+    """Flags for a submodule."""
+
+    def __init__(self, repo: "Repo", file_path: Union[PathLike, None] = None) -> None:
+        """Initialize this Index instance, optionally from the given `file_path`.
+
+        If no `file_path` is given, we will be created from the current index file.
+
+        If a stream is not given, the stream will be initialized from the current
+        repository's index on demand.
+        """
+        self.repo = repo
+        self.version = self._VERSION
+        self._extension_data = b""
+        self._file_path: PathLike = file_path or self._index_path()
+
+    def _set_cache_(self, attr: str) -> None:
+        if attr == "entries":
+            try:
+                fd = os.open(self._file_path, os.O_RDONLY)
+            except OSError:
+                # In new repositories, there may be no index, which means we are empty.
+                self.entries: Dict[Tuple[PathLike, StageType], IndexEntry] = {}
+                return
+            # END exception handling
+
+            try:
+                stream = file_contents_ro(fd, stream=True, allow_mmap=True)
+            finally:
+                os.close(fd)
+
+            self._deserialize(stream)
+        else:
+            super()._set_cache_(attr)
+
+    def _index_path(self) -> PathLike:
+        if self.repo.git_dir:
+            return join_path_native(self.repo.git_dir, "index")
+        else:
+            raise GitCommandError("No git directory given to join index path")
+
+    @property
+    def path(self) -> PathLike:
+        """:return: Path to the index file we are representing"""
+        return self._file_path
+
+    def _delete_entries_cache(self) -> None:
+        """Safely clear the entries cache so it can be recreated."""
+        try:
+            del self.entries
+        except AttributeError:
+            # It failed in Python 2.6.5 with AttributeError.
+            # FIXME: Look into whether we can just remove this except clause now.
+            pass
+        # END exception handling
+
+    # { Serializable Interface
+
+    def _deserialize(self, stream: IO) -> "IndexFile":
+        """Initialize this instance with index values read from the given stream."""
+        self.version, self.entries, self._extension_data, _conten_sha = read_cache(stream)
+        return self
+
+    def _entries_sorted(self) -> List[IndexEntry]:
+        """:return: List of entries, in a sorted fashion, first by path, then by stage"""
+        return sorted(self.entries.values(), key=lambda e: (e.path, e.stage))
+
+    def _serialize(self, stream: IO, ignore_extension_data: bool = False) -> "IndexFile":
+        entries = self._entries_sorted()
+        extension_data = self._extension_data  # type: Union[None, bytes]
+        if ignore_extension_data:
+            extension_data = None
+        write_cache(entries, stream, extension_data)
+        return self
+
+    # } END serializable interface
+
+    def write(
+        self,
+        file_path: Union[None, PathLike] = None,
+        ignore_extension_data: bool = False,
+    ) -> None:
+        """Write the current state to our file path or to the given one.
+
+        :param file_path:
+            If ``None``, we will write to our stored file path from which we have been
+            initialized. Otherwise we write to the given file path. Please note that
+            this will change the `file_path` of this index to the one you gave.
+
+        :param ignore_extension_data:
+            If ``True``, the TREE type extension data read in the index will not be
+            written to disk. NOTE that no extension data is actually written. Use this
+            if you have altered the index and would like to use
+            :manpage:`git-write-tree(1)` afterwards to create a tree representing your
+            written changes. If this data is present in the written index,
+            :manpage:`git-write-tree(1)` will instead write the stored/cached tree.
+            Alternatively, use :meth:`write_tree` to handle this case automatically.
+        """
+        # Make sure we have our entries read before getting a write lock.
+        # Otherwise it would be done when streaming.
+        # This can happen if one doesn't change the index, but writes it right away.
+        self.entries  # noqa: B018
+        lfd = LockedFD(file_path or self._file_path)
+        stream = lfd.open(write=True, stream=True)
+
+        try:
+            self._serialize(stream, ignore_extension_data)
+        except BaseException:
+            lfd.rollback()
+            raise
+
+        lfd.commit()
+
+        # Make sure we represent what we have written.
+        if file_path is not None:
+            self._file_path = file_path
+
+    @post_clear_cache
+    @default_index
+    def merge_tree(self, rhs: Treeish, base: Union[None, Treeish] = None) -> "IndexFile":
+        """Merge the given `rhs` treeish into the current index, possibly taking
+        a common base treeish into account.
+
+        As opposed to the :func:`from_tree` method, this allows you to use an already
+        existing tree as the left side of the merge.
+
+        :param rhs:
+            Treeish reference pointing to the 'other' side of the merge.
+
+        :param base:
+            Optional treeish reference pointing to the common base of `rhs` and this
+            index which equals lhs.
+
+        :return:
+            self (containing the merge and possibly unmerged entries in case of
+            conflicts)
+
+        :raise git.exc.GitCommandError:
+            If there is a merge conflict. The error will be raised at the first
+            conflicting path. If you want to have proper merge resolution to be done by
+            yourself, you have to commit the changed index (or make a valid tree from
+            it) and retry with a three-way :meth:`index.from_tree <from_tree>` call.
+        """
+        # -i : ignore working tree status
+        # --aggressive : handle more merge cases
+        # -m : do an actual merge
+        args: List[Union[Treeish, str]] = ["--aggressive", "-i", "-m"]
+        if base is not None:
+            args.append(base)
+        args.append(rhs)
+
+        self.repo.git.read_tree(args)
+        return self
+
+    @classmethod
+    def new(cls, repo: "Repo", *tree_sha: Union[str, Tree]) -> "IndexFile":
+        """Merge the given treeish revisions into a new index which is returned.
+
+        This method behaves like ``git-read-tree --aggressive`` when doing the merge.
+
+        :param repo:
+            The repository treeish are located in.
+
+        :param tree_sha:
+            20 byte or 40 byte tree sha or tree objects.
+
+        :return:
+            New :class:`IndexFile` instance. Its path will be undefined.
+            If you intend to write such a merged Index, supply an alternate
+            ``file_path`` to its :meth:`write` method.
+        """
+        tree_sha_bytes: List[bytes] = [to_bin_sha(str(t)) for t in tree_sha]
+        base_entries = aggressive_tree_merge(repo.odb, tree_sha_bytes)
+
+        inst = cls(repo)
+        # Convert to entries dict.
+        entries: Dict[Tuple[PathLike, int], IndexEntry] = dict(
+            zip(
+                ((e.path, e.stage) for e in base_entries),
+                (IndexEntry.from_base(e) for e in base_entries),
+            )
+        )
+
+        inst.entries = entries
+        return inst
+
+    @classmethod
+    def from_tree(cls, repo: "Repo", *treeish: Treeish, **kwargs: Any) -> "IndexFile":
+        R"""Merge the given treeish revisions into a new index which is returned.
+        The original index will remain unaltered.
+
+        :param repo:
+            The repository treeish are located in.
+
+        :param treeish:
+            One, two or three :class:`~git.objects.tree.Tree` objects,
+            :class:`~git.objects.commit.Commit`\s or 40 byte hexshas.
+
+            The result changes according to the amount of trees:
+
+            1. If 1 Tree is given, it will just be read into a new index.
+            2. If 2 Trees are given, they will be merged into a new index using a two
+               way merge algorithm. Tree 1 is the 'current' tree, tree 2 is the 'other'
+               one. It behaves like a fast-forward.
+            3. If 3 Trees are given, a 3-way merge will be performed with the first tree
+               being the common ancestor of tree 2 and tree 3. Tree 2 is the 'current'
+               tree, tree 3 is the 'other' one.
+
+        :param kwargs:
+            Additional arguments passed to :manpage:`git-read-tree(1)`.
+
+        :return:
+            New :class:`IndexFile` instance. It will point to a temporary index location
+            which does not exist anymore. If you intend to write such a merged Index,
+            supply an alternate ``file_path`` to its :meth:`write` method.
+
+        :note:
+            In the three-way merge case, ``--aggressive`` will be specified to
+            automatically resolve more cases in a commonly correct manner. Specify
+            ``trivial=True`` as a keyword argument to override that.
+
+            As the underlying :manpage:`git-read-tree(1)` command takes into account the
+            current index, it will be temporarily moved out of the way to prevent any
+            unexpected interference.
+        """
+        if len(treeish) == 0 or len(treeish) > 3:
+            raise ValueError("Please specify between 1 and 3 treeish, got %i" % len(treeish))
+
+        arg_list: List[Union[Treeish, str]] = []
+        # Ignore that the working tree and index possibly are out of date.
+        if len(treeish) > 1:
+            # Drop unmerged entries when reading our index and merging.
+            arg_list.append("--reset")
+            # Handle non-trivial cases the way a real merge does.
+            arg_list.append("--aggressive")
+        # END merge handling
+
+        # Create the temporary file in the .git directory to be sure renaming
+        # works - /tmp/ directories could be on another device.
+        with _named_temporary_file_for_subprocess(repo.git_dir) as tmp_index:
+            arg_list.append("--index-output=%s" % tmp_index)
+            arg_list.extend(treeish)
+
+            # Move the current index out of the way - otherwise the merge may fail as it
+            # considers existing entries. Moving it essentially clears the index.
+            # Unfortunately there is no 'soft' way to do it.
+            # The TemporaryFileSwap ensures the original file gets put back.
+            with TemporaryFileSwap(join_path_native(repo.git_dir, "index")):
+                repo.git.read_tree(*arg_list, **kwargs)
+                index = cls(repo, tmp_index)
+                index.entries  # noqa: B018 # Force it to read the file as we will delete the temp-file.
+                return index
+            # END index merge handling
+
+    # UTILITIES
+
+    @unbare_repo
+    def _iter_expand_paths(self: "IndexFile", paths: Sequence[PathLike]) -> Iterator[PathLike]:
+        """Expand the directories in list of paths to the corresponding paths
+        accordingly.
+
+        :note:
+            git will add items multiple times even if a glob overlapped with manually
+            specified paths or if paths where specified multiple times - we respect that
+            and do not prune.
+        """
+
+        def raise_exc(e: Exception) -> NoReturn:
+            raise e
+
+        r = str(self.repo.working_tree_dir)
+        rs = r + os.sep
+        for path in paths:
+            abs_path = str(path)
+            if not osp.isabs(abs_path):
+                abs_path = osp.join(r, path)
+            # END make absolute path
+
+            try:
+                st = os.lstat(abs_path)  # Handles non-symlinks as well.
+            except OSError:
+                # The lstat call may fail as the path may contain globs as well.
+                pass
+            else:
+                if S_ISLNK(st.st_mode):
+                    yield abs_path.replace(rs, "")
+                    continue
+            # END check symlink
+
+            # If the path is not already pointing to an existing file, resolve globs if possible.
+            if not os.path.exists(abs_path) and ("?" in abs_path or "*" in abs_path or "[" in abs_path):
+                resolved_paths = glob.glob(abs_path)
+                # not abs_path in resolved_paths:
+                #   A glob() resolving to the same path we are feeding it with is a
+                #   glob() that failed to resolve. If we continued calling ourselves
+                #   we'd endlessly recurse. If the condition below evaluates to true
+                #   then we are likely dealing with a file whose name contains wildcard
+                #   characters.
+                if abs_path not in resolved_paths:
+                    for f in self._iter_expand_paths(glob.glob(abs_path)):
+                        yield str(f).replace(rs, "")
+                    continue
+            # END glob handling
+            try:
+                for root, _dirs, files in os.walk(abs_path, onerror=raise_exc):
+                    for rela_file in files:
+                        # Add relative paths only.
+                        yield osp.join(root.replace(rs, ""), rela_file)
+                    # END for each file in subdir
+                # END for each subdirectory
+            except OSError:
+                # It was a file or something that could not be iterated.
+                yield abs_path.replace(rs, "")
+            # END path exception handling
+        # END for each path
+
+    def _write_path_to_stdin(
+        self,
+        proc: "Popen",
+        filepath: PathLike,
+        item: PathLike,
+        fmakeexc: Callable[..., GitError],
+        fprogress: Callable[[PathLike, bool, PathLike], None],
+        read_from_stdout: bool = True,
+    ) -> Union[None, str]:
+        """Write path to ``proc.stdin`` and make sure it processes the item, including
+        progress.
+
+        :return:
+            stdout string
+
+        :param read_from_stdout:
+            If ``True``, ``proc.stdout`` will be read after the item was sent to stdin.
+            In that case, it will return ``None``.
+
+        :note:
+            There is a bug in :manpage:`git-update-index(1)` that prevents it from
+            sending reports just in time. This is why we have a version that tries to
+            read stdout and one which doesn't. In fact, the stdout is not important as
+            the piped-in files are processed anyway and just in time.
+
+        :note:
+            Newlines are essential here, git's behaviour is somewhat inconsistent on
+            this depending on the version, hence we try our best to deal with newlines
+            carefully. Usually the last newline will not be sent, instead we will close
+            stdin to break the pipe.
+        """
+        fprogress(filepath, False, item)
+        rval: Union[None, str] = None
+
+        if proc.stdin is not None:
+            try:
+                proc.stdin.write(("%s\n" % filepath).encode(defenc))
+            except IOError as e:
+                # Pipe broke, usually because some error happened.
+                raise fmakeexc() from e
+            # END write exception handling
+            proc.stdin.flush()
+
+        if read_from_stdout and proc.stdout is not None:
+            rval = proc.stdout.readline().strip()
+        fprogress(filepath, True, item)
+        return rval
+
+    def iter_blobs(
+        self, predicate: Callable[[Tuple[StageType, Blob]], bool] = lambda t: True
+    ) -> Iterator[Tuple[StageType, Blob]]:
+        """
+        :return:
+            Iterator yielding tuples of :class:`~git.objects.blob.Blob` objects and
+            stages, tuple(stage, Blob).
+
+        :param predicate:
+            Function(t) returning ``True`` if tuple(stage, Blob) should be yielded by
+            the iterator. A default filter, the `~git.index.typ.BlobFilter`, allows you
+            to yield blobs only if they match a given list of paths.
+        """
+        for entry in self.entries.values():
+            blob = entry.to_blob(self.repo)
+            blob.size = entry.size
+            output = (entry.stage, blob)
+            if predicate(output):
+                yield output
+        # END for each entry
+
+    def unmerged_blobs(self) -> Dict[PathLike, List[Tuple[StageType, Blob]]]:
+        """
+        :return:
+            Dict(path : list(tuple(stage, Blob, ...))), being a dictionary associating a
+            path in the index with a list containing sorted stage/blob pairs.
+
+        :note:
+            Blobs that have been removed in one side simply do not exist in the given
+            stage. That is, a file removed on the 'other' branch whose entries are at
+            stage 3 will not have a stage 3 entry.
+        """
+        is_unmerged_blob = lambda t: t[0] != 0
+        path_map: Dict[PathLike, List[Tuple[StageType, Blob]]] = {}
+        for stage, blob in self.iter_blobs(is_unmerged_blob):
+            path_map.setdefault(blob.path, []).append((stage, blob))
+        # END for each unmerged blob
+        for line in path_map.values():
+            line.sort()
+
+        return path_map
+
+    @classmethod
+    def entry_key(cls, *entry: Union[BaseIndexEntry, PathLike, StageType]) -> Tuple[PathLike, StageType]:
+        return entry_key(*entry)
+
+    def resolve_blobs(self, iter_blobs: Iterator[Blob]) -> "IndexFile":
+        """Resolve the blobs given in blob iterator.
+
+        This will effectively remove the index entries of the respective path at all
+        non-null stages and add the given blob as new stage null blob.
+
+        For each path there may only be one blob, otherwise a :exc:`ValueError` will be
+        raised claiming the path is already at stage 0.
+
+        :raise ValueError:
+            If one of the blobs already existed at stage 0.
+
+        :return:
+            self
+
+        :note:
+            You will have to write the index manually once you are done, i.e.
+            ``index.resolve_blobs(blobs).write()``.
+        """
+        for blob in iter_blobs:
+            stage_null_key = (blob.path, 0)
+            if stage_null_key in self.entries:
+                raise ValueError("Path %r already exists at stage 0" % str(blob.path))
+            # END assert blob is not stage 0 already
+
+            # Delete all possible stages.
+            for stage in (1, 2, 3):
+                try:
+                    del self.entries[(blob.path, stage)]
+                except KeyError:
+                    pass
+                # END ignore key errors
+            # END for each possible stage
+
+            self.entries[stage_null_key] = IndexEntry.from_blob(blob)
+        # END for each blob
+
+        return self
+
+    def update(self) -> "IndexFile":
+        """Reread the contents of our index file, discarding all cached information
+        we might have.
+
+        :note:
+            This is a possibly dangerous operations as it will discard your changes to
+            :attr:`index.entries <entries>`.
+
+        :return:
+            self
+        """
+        self._delete_entries_cache()
+        # Allows to lazily reread on demand.
+        return self
+
+    def write_tree(self) -> Tree:
+        """Write this index to a corresponding :class:`~git.objects.tree.Tree` object
+        into the repository's object database and return it.
+
+        :return:
+            :class:`~git.objects.tree.Tree` object representing this index.
+
+        :note:
+            The tree will be written even if one or more objects the tree refers to does
+            not yet exist in the object database. This could happen if you added entries
+            to the index directly.
+
+        :raise ValueError:
+            If there are no entries in the cache.
+
+        :raise git.exc.UnmergedEntriesError:
+        """
+        # We obtain no lock as we just flush our contents to disk as tree.
+        # If we are a new index, the entries access will load our data accordingly.
+        mdb = MemoryDB()
+        entries = self._entries_sorted()
+        binsha, tree_items = write_tree_from_cache(entries, mdb, slice(0, len(entries)))
+
+        # Copy changed trees only.
+        mdb.stream_copy(mdb.sha_iter(), self.repo.odb)
+
+        # Note: Additional deserialization could be saved if write_tree_from_cache would
+        # return sorted tree entries.
+        root_tree = Tree(self.repo, binsha, path="")
+        root_tree._cache = tree_items
+        return root_tree
+
+    def _process_diff_args(
+        self,
+        args: List[Union[PathLike, "git_diff.Diffable"]],
+    ) -> List[Union[PathLike, "git_diff.Diffable"]]:
+        try:
+            args.pop(args.index(self))
+        except IndexError:
+            pass
+        # END remove self
+        return args
+
+    def _to_relative_path(self, path: PathLike) -> PathLike:
+        """
+        :return:
+            Version of path relative to our git directory or raise :exc:`ValueError` if
+            it is not within our git directory.
+
+        :raise ValueError:
+        """
+        if not osp.isabs(path):
+            return path
+        if self.repo.bare:
+            raise InvalidGitRepositoryError("require non-bare repository")
+        if not osp.normpath(str(path)).startswith(str(self.repo.working_tree_dir)):
+            raise ValueError("Absolute path %r is not in git repository at %r" % (path, self.repo.working_tree_dir))
+        return os.path.relpath(path, self.repo.working_tree_dir)
+
+    def _preprocess_add_items(
+        self, items: Union[PathLike, Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]]
+    ) -> Tuple[List[PathLike], List[BaseIndexEntry]]:
+        """Split the items into two lists of path strings and BaseEntries."""
+        paths = []
+        entries = []
+        # if it is a string put in list
+        if isinstance(items, (str, os.PathLike)):
+            items = [items]
+
+        for item in items:
+            if isinstance(item, (str, os.PathLike)):
+                paths.append(self._to_relative_path(item))
+            elif isinstance(item, (Blob, Submodule)):
+                entries.append(BaseIndexEntry.from_blob(item))
+            elif isinstance(item, BaseIndexEntry):
+                entries.append(item)
+            else:
+                raise TypeError("Invalid Type: %r" % item)
+        # END for each item
+        return paths, entries
+
+    def _store_path(self, filepath: PathLike, fprogress: Callable) -> BaseIndexEntry:
+        """Store file at filepath in the database and return the base index entry.
+
+        :note:
+            This needs the :func:`~git.index.util.git_working_dir` decorator active!
+            This must be ensured in the calling code.
+        """
+        st = os.lstat(filepath)  # Handles non-symlinks as well.
+        if S_ISLNK(st.st_mode):
+            # In PY3, readlink is a string, but we need bytes.
+            # In PY2, it was just OS encoded bytes, we assumed UTF-8.
+            open_stream: Callable[[], BinaryIO] = lambda: BytesIO(force_bytes(os.readlink(filepath), encoding=defenc))
+        else:
+            open_stream = lambda: open(filepath, "rb")
+        with open_stream() as stream:
+            fprogress(filepath, False, filepath)
+            istream = self.repo.odb.store(IStream(Blob.type, st.st_size, stream))
+            fprogress(filepath, True, filepath)
+        return BaseIndexEntry(
+            (
+                stat_mode_to_index_mode(st.st_mode),
+                istream.binsha,
+                0,
+                to_native_path_linux(filepath),
+            )
+        )
+
+    @unbare_repo
+    @git_working_dir
+    def _entries_for_paths(
+        self,
+        paths: List[str],
+        path_rewriter: Union[Callable, None],
+        fprogress: Callable,
+        entries: List[BaseIndexEntry],
+    ) -> List[BaseIndexEntry]:
+        entries_added: List[BaseIndexEntry] = []
+        if path_rewriter:
+            for path in paths:
+                if osp.isabs(path):
+                    abspath = path
+                    gitrelative_path = path[len(str(self.repo.working_tree_dir)) + 1 :]
+                else:
+                    gitrelative_path = path
+                    if self.repo.working_tree_dir:
+                        abspath = osp.join(self.repo.working_tree_dir, gitrelative_path)
+                # END obtain relative and absolute paths
+
+                blob = Blob(
+                    self.repo,
+                    Blob.NULL_BIN_SHA,
+                    stat_mode_to_index_mode(os.stat(abspath).st_mode),
+                    to_native_path_linux(gitrelative_path),
+                )
+                # TODO: variable undefined
+                entries.append(BaseIndexEntry.from_blob(blob))
+            # END for each path
+            del paths[:]
+        # END rewrite paths
+
+        # HANDLE PATHS
+        assert len(entries_added) == 0
+        for filepath in self._iter_expand_paths(paths):
+            entries_added.append(self._store_path(filepath, fprogress))
+        # END for each filepath
+        # END path handling
+        return entries_added
+
+    def add(
+        self,
+        items: Union[PathLike, Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]],
+        force: bool = True,
+        fprogress: Callable = lambda *args: None,
+        path_rewriter: Union[Callable[..., PathLike], None] = None,
+        write: bool = True,
+        write_extension_data: bool = False,
+    ) -> List[BaseIndexEntry]:
+        R"""Add files from the working tree, specific blobs, or
+        :class:`~git.index.typ.BaseIndexEntry`\s to the index.
+
+        :param items:
+            Multiple types of items are supported, types can be mixed within one call.
+            Different types imply a different handling. File paths may generally be
+            relative or absolute.
+
+            - path string
+
+                Strings denote a relative or absolute path into the repository pointing
+                to an existing file, e.g., ``CHANGES``, `lib/myfile.ext``,
+                ``/home/gitrepo/lib/myfile.ext``.
+
+                Absolute paths must start with working tree directory of this index's
+                repository to be considered valid. For example, if it was initialized
+                with a non-normalized path, like ``/root/repo/../repo``, absolute paths
+                to be added must start with ``/root/repo/../repo``.
+
+                Paths provided like this must exist. When added, they will be written
+                into the object database.
+
+                PathStrings may contain globs, such as ``lib/__init__*``. Or they can be
+                directories like ``lib``, which will add all the files within the
+                directory and subdirectories.
+
+                This equals a straight :manpage:`git-add(1)`.
+
+                They are added at stage 0.
+
+            - :class:~`git.objects.blob.Blob` or
+              :class:`~git.objects.submodule.base.Submodule` object
+
+                Blobs are added as they are assuming a valid mode is set.
+
+                The file they refer to may or may not exist in the file system, but must
+                be a path relative to our repository.
+
+                If their sha is null (40*0), their path must exist in the file system
+                relative to the git repository as an object will be created from the
+                data at the path.
+
+                The handling now very much equals the way string paths are processed,
+                except that the mode you have set will be kept. This allows you to
+                create symlinks by settings the mode respectively and writing the target
+                of the symlink directly into the file. This equals a default Linux
+                symlink which is not dereferenced automatically, except that it can be
+                created on filesystems not supporting it as well.
+
+                Please note that globs or directories are not allowed in
+                :class:`~git.objects.blob.Blob` objects.
+
+                They are added at stage 0.
+
+            - :class:`~git.index.typ.BaseIndexEntry` or type
+
+                Handling equals the one of :class:~`git.objects.blob.Blob` objects, but
+                the stage may be explicitly set. Please note that Index Entries require
+                binary sha's.
+
+        :param force:
+            **CURRENTLY INEFFECTIVE**
+            If ``True``, otherwise ignored or excluded files will be added anyway. As
+            opposed to the :manpage:`git-add(1)` command, we enable this flag by default
+            as the API user usually wants the item to be added even though they might be
+            excluded.
+
+        :param fprogress:
+            Function with signature ``f(path, done=False, item=item)`` called for each
+            path to be added, one time once it is about to be added where ``done=False``
+            and once after it was added where ``done=True``.
+
+            ``item`` is set to the actual item we handle, either a path or a
+            :class:`~git.index.typ.BaseIndexEntry`.
+
+            Please note that the processed path is not guaranteed to be present in the
+            index already as the index is currently being processed.
+
+        :param path_rewriter:
+            Function, with signature ``(string) func(BaseIndexEntry)``, returning a path
+            for each passed entry which is the path to be actually recorded for the
+            object created from :attr:`entry.path <git.index.typ.BaseIndexEntry.path>`.
+            This allows you to write an index which is not identical to the layout of
+            the actual files on your hard-disk. If not ``None`` and `items` contain
+            plain paths, these paths will be converted to Entries beforehand and passed
+            to the path_rewriter. Please note that ``entry.path`` is relative to the git
+            repository.
+
+        :param write:
+            If ``True``, the index will be written once it was altered. Otherwise the
+            changes only exist in memory and are not available to git commands.
+
+        :param write_extension_data:
+            If ``True``, extension data will be written back to the index. This can lead
+            to issues in case it is containing the 'TREE' extension, which will cause
+            the :manpage:`git-commit(1)` command to write an old tree, instead of a new
+            one representing the now changed index.
+
+            This doesn't matter if you use :meth:`IndexFile.commit`, which ignores the
+            'TREE' extension altogether. You should set it to ``True`` if you intend to
+            use :meth:`IndexFile.commit` exclusively while maintaining support for
+            third-party extensions. Besides that, you can usually safely ignore the
+            built-in extensions when using GitPython on repositories that are not
+            handled manually at all.
+
+            All current built-in extensions are listed here:
+            https://git-scm.com/docs/index-format
+
+        :return:
+            List of :class:`~git.index.typ.BaseIndexEntry`\s representing the entries
+            just actually added.
+
+        :raise OSError:
+            If a supplied path did not exist. Please note that
+            :class:`~git.index.typ.BaseIndexEntry` objects that do not have a null sha
+            will be added even if their paths do not exist.
+        """
+        # Sort the entries into strings and Entries.
+        # Blobs are converted to entries automatically.
+        # Paths can be git-added. For everything else we use git-update-index.
+        paths, entries = self._preprocess_add_items(items)
+        entries_added: List[BaseIndexEntry] = []
+        # This code needs a working tree, so we try not to run it unless required.
+        # That way, we are OK on a bare repository as well.
+        # If there are no paths, the rewriter has nothing to do either.
+        if paths:
+            entries_added.extend(self._entries_for_paths(paths, path_rewriter, fprogress, entries))
+
+        # HANDLE ENTRIES
+        if entries:
+            null_mode_entries = [e for e in entries if e.mode == 0]
+            if null_mode_entries:
+                raise ValueError(
+                    "At least one Entry has a null-mode - please use index.remove to remove files for clarity"
+                )
+            # END null mode should be remove
+
+            # HANDLE ENTRY OBJECT CREATION
+            # Create objects if required, otherwise go with the existing shas.
+            null_entries_indices = [i for i, e in enumerate(entries) if e.binsha == Object.NULL_BIN_SHA]
+            if null_entries_indices:
+
+                @git_working_dir
+                def handle_null_entries(self: "IndexFile") -> None:
+                    for ei in null_entries_indices:
+                        null_entry = entries[ei]
+                        new_entry = self._store_path(null_entry.path, fprogress)
+
+                        # Update null entry.
+                        entries[ei] = BaseIndexEntry(
+                            (
+                                null_entry.mode,
+                                new_entry.binsha,
+                                null_entry.stage,
+                                null_entry.path,
+                            )
+                        )
+                    # END for each entry index
+
+                # END closure
+
+                handle_null_entries(self)
+            # END null_entry handling
+
+            # REWRITE PATHS
+            # If we have to rewrite the entries, do so now, after we have generated all
+            # object sha's.
+            if path_rewriter:
+                for i, e in enumerate(entries):
+                    entries[i] = BaseIndexEntry((e.mode, e.binsha, e.stage, path_rewriter(e)))
+                # END for each entry
+            # END handle path rewriting
+
+            # Just go through the remaining entries and provide progress info.
+            for i, entry in enumerate(entries):
+                progress_sent = i in null_entries_indices
+                if not progress_sent:
+                    fprogress(entry.path, False, entry)
+                    fprogress(entry.path, True, entry)
+                # END handle progress
+            # END for each entry
+            entries_added.extend(entries)
+        # END if there are base entries
+
+        # FINALIZE
+        # Add the new entries to this instance.
+        for entry in entries_added:
+            self.entries[(entry.path, 0)] = IndexEntry.from_base(entry)
+
+        if write:
+            self.write(ignore_extension_data=not write_extension_data)
+        # END handle write
+
+        return entries_added
+
+    def _items_to_rela_paths(
+        self,
+        items: Union[PathLike, Sequence[Union[PathLike, BaseIndexEntry, Blob, Submodule]]],
+    ) -> List[PathLike]:
+        """Returns a list of repo-relative paths from the given items which
+        may be absolute or relative paths, entries or blobs."""
+        paths = []
+        # If string, put in list.
+        if isinstance(items, (str, os.PathLike)):
+            items = [items]
+
+        for item in items:
+            if isinstance(item, (BaseIndexEntry, (Blob, Submodule))):
+                paths.append(self._to_relative_path(item.path))
+            elif isinstance(item, (str, os.PathLike)):
+                paths.append(self._to_relative_path(item))
+            else:
+                raise TypeError("Invalid item type: %r" % item)
+        # END for each item
+        return paths
+
+    @post_clear_cache
+    @default_index
+    def remove(
+        self,
+        items: Union[PathLike, Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]],
+        working_tree: bool = False,
+        **kwargs: Any,
+    ) -> List[str]:
+        R"""Remove the given items from the index and optionally from the working tree
+        as well.
+
+        :param items:
+            Multiple types of items are supported which may be be freely mixed.
+
+            - path string
+
+                Remove the given path at all stages. If it is a directory, you must
+                specify the ``r=True`` keyword argument to remove all file entries below
+                it. If absolute paths are given, they will be converted to a path
+                relative to the git repository directory containing the working tree
+
+                The path string may include globs, such as ``*.c``.
+
+            - :class:~`git.objects.blob.Blob` object
+
+                Only the path portion is used in this case.
+
+            - :class:`~git.index.typ.BaseIndexEntry` or compatible type
+
+                The only relevant information here is the path. The stage is ignored.
+
+        :param working_tree:
+            If ``True``, the entry will also be removed from the working tree,
+            physically removing the respective file. This may fail if there are
+            uncommitted changes in it.
+
+        :param kwargs:
+            Additional keyword arguments to be passed to :manpage:`git-rm(1)`, such as
+            ``r`` to allow recursive removal.
+
+        :return:
+            List(path_string, ...) list of repository relative paths that have been
+            removed effectively.
+
+            This is interesting to know in case you have provided a directory or globs.
+            Paths are relative to the repository.
+        """
+        args = []
+        if not working_tree:
+            args.append("--cached")
+        args.append("--")
+
+        # Preprocess paths.
+        paths = self._items_to_rela_paths(items)
+        removed_paths = self.repo.git.rm(args, paths, **kwargs).splitlines()
+
+        # Process output to gain proper paths.
+        # rm 'path'
+        return [p[4:-1] for p in removed_paths]
+
+    @post_clear_cache
+    @default_index
+    def move(
+        self,
+        items: Union[PathLike, Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]],
+        skip_errors: bool = False,
+        **kwargs: Any,
+    ) -> List[Tuple[str, str]]:
+        """Rename/move the items, whereas the last item is considered the destination of
+        the move operation.
+
+        If the destination is a file, the first item (of two) must be a file as well.
+
+        If the destination is a directory, it may be preceded by one or more directories
+        or files.
+
+        The working tree will be affected in non-bare repositories.
+
+        :param items:
+            Multiple types of items are supported, please see the :meth:`remove` method
+            for reference.
+
+        :param skip_errors:
+            If ``True``, errors such as ones resulting from missing source files will be
+            skipped.
+
+        :param kwargs:
+            Additional arguments you would like to pass to :manpage:`git-mv(1)`, such as
+            ``dry_run`` or ``force``.
+
+        :return:
+            List(tuple(source_path_string, destination_path_string), ...)
+
+            A list of pairs, containing the source file moved as well as its actual
+            destination. Relative to the repository root.
+
+        :raise ValueError:
+            If only one item was given.
+
+        :raise git.exc.GitCommandError:
+            If git could not handle your request.
+        """
+        args = []
+        if skip_errors:
+            args.append("-k")
+
+        paths = self._items_to_rela_paths(items)
+        if len(paths) < 2:
+            raise ValueError("Please provide at least one source and one destination of the move operation")
+
+        was_dry_run = kwargs.pop("dry_run", kwargs.pop("n", None))
+        kwargs["dry_run"] = True
+
+        # First execute rename in dry run so the command tells us what it actually does
+        # (for later output).
+        out = []
+        mvlines = self.repo.git.mv(args, paths, **kwargs).splitlines()
+
+        # Parse result - first 0:n/2 lines are 'checking ', the remaining ones are the
+        # 'renaming' ones which we parse.
+        for ln in range(int(len(mvlines) / 2), len(mvlines)):
+            tokens = mvlines[ln].split(" to ")
+            assert len(tokens) == 2, "Too many tokens in %s" % mvlines[ln]
+
+            # [0] = Renaming x
+            # [1] = y
+            out.append((tokens[0][9:], tokens[1]))
+        # END for each line to parse
+
+        # Either prepare for the real run, or output the dry-run result.
+        if was_dry_run:
+            return out
+        # END handle dry run
+
+        # Now apply the actual operation.
+        kwargs.pop("dry_run")
+        self.repo.git.mv(args, paths, **kwargs)
+
+        return out
+
+    def commit(
+        self,
+        message: str,
+        parent_commits: Union[List[Commit], None] = None,
+        head: bool = True,
+        author: Union[None, Actor] = None,
+        committer: Union[None, Actor] = None,
+        author_date: Union[datetime.datetime, str, None] = None,
+        commit_date: Union[datetime.datetime, str, None] = None,
+        skip_hooks: bool = False,
+    ) -> Commit:
+        """Commit the current default index file, creating a
+        :class:`~git.objects.commit.Commit` object.
+
+        For more information on the arguments, see
+        :meth:`Commit.create_from_tree <git.objects.commit.Commit.create_from_tree>`.
+
+        :note:
+            If you have manually altered the :attr:`entries` member of this instance,
+            don't forget to :meth:`write` your changes to disk beforehand.
+
+        :note:
+            Passing ``skip_hooks=True`` is the equivalent of using ``-n`` or
+            ``--no-verify`` on the command line.
+
+        :return:
+            :class:`~git.objects.commit.Commit` object representing the new commit
+        """
+        if not skip_hooks:
+            run_commit_hook("pre-commit", self)
+
+            self._write_commit_editmsg(message)
+            run_commit_hook("commit-msg", self, self._commit_editmsg_filepath())
+            message = self._read_commit_editmsg()
+            self._remove_commit_editmsg()
+        tree = self.write_tree()
+        rval = Commit.create_from_tree(
+            self.repo,
+            tree,
+            message,
+            parent_commits,
+            head,
+            author=author,
+            committer=committer,
+            author_date=author_date,
+            commit_date=commit_date,
+        )
+        if not skip_hooks:
+            run_commit_hook("post-commit", self)
+        return rval
+
+    def _write_commit_editmsg(self, message: str) -> None:
+        with open(self._commit_editmsg_filepath(), "wb") as commit_editmsg_file:
+            commit_editmsg_file.write(message.encode(defenc))
+
+    def _remove_commit_editmsg(self) -> None:
+        os.remove(self._commit_editmsg_filepath())
+
+    def _read_commit_editmsg(self) -> str:
+        with open(self._commit_editmsg_filepath(), "rb") as commit_editmsg_file:
+            return commit_editmsg_file.read().decode(defenc)
+
+    def _commit_editmsg_filepath(self) -> str:
+        return osp.join(self.repo.common_dir, "COMMIT_EDITMSG")
+
+    def _flush_stdin_and_wait(cls, proc: "Popen[bytes]", ignore_stdout: bool = False) -> bytes:
+        stdin_IO = proc.stdin
+        if stdin_IO:
+            stdin_IO.flush()
+            stdin_IO.close()
+
+        stdout = b""
+        if not ignore_stdout and proc.stdout:
+            stdout = proc.stdout.read()
+
+        if proc.stdout:
+            proc.stdout.close()
+            proc.wait()
+        return stdout
+
+    @default_index
+    def checkout(
+        self,
+        paths: Union[None, Iterable[PathLike]] = None,
+        force: bool = False,
+        fprogress: Callable = lambda *args: None,
+        **kwargs: Any,
+    ) -> Union[None, Iterator[PathLike], Sequence[PathLike]]:
+        """Check out the given paths or all files from the version known to the index
+        into the working tree.
+
+        :note:
+            Be sure you have written pending changes using the :meth:`write` method in
+            case you have altered the entries dictionary directly.
+
+        :param paths:
+            If ``None``, all paths in the index will be checked out.
+            Otherwise an iterable of relative or absolute paths or a single path
+            pointing to files or directories in the index is expected.
+
+        :param force:
+            If ``True``, existing files will be overwritten even if they contain local
+            modifications.
+            If ``False``, these will trigger a :exc:`~git.exc.CheckoutError`.
+
+        :param fprogress:
+            See :meth:`IndexFile.add` for signature and explanation.
+
+            The provided progress information will contain ``None`` as path and item if
+            no explicit paths are given. Otherwise progress information will be send
+            prior and after a file has been checked out.
+
+        :param kwargs:
+            Additional arguments to be passed to :manpage:`git-checkout-index(1)`.
+
+        :return:
+            Iterable yielding paths to files which have been checked out and are
+            guaranteed to match the version stored in the index.
+
+        :raise git.exc.CheckoutError:
+            * If at least one file failed to be checked out. This is a summary, hence it
+              will checkout as many files as it can anyway.
+            * If one of files or directories do not exist in the index (as opposed to
+              the original git command, which ignores them).
+
+        :raise git.exc.GitCommandError:
+            If error lines could not be parsed - this truly is an exceptional state.
+
+        :note:
+            The checkout is limited to checking out the files in the index. Files which
+            are not in the index anymore and exist in the working tree will not be
+            deleted. This behaviour is fundamentally different to ``head.checkout``,
+            i.e. if you want :manpage:`git-checkout(1)`-like behaviour, use
+            ``head.checkout`` instead of ``index.checkout``.
+        """
+        args = ["--index"]
+        if force:
+            args.append("--force")
+
+        failed_files = []
+        failed_reasons = []
+        unknown_lines = []
+
+        def handle_stderr(proc: "Popen[bytes]", iter_checked_out_files: Iterable[PathLike]) -> None:
+            stderr_IO = proc.stderr
+            if not stderr_IO:
+                return  # Return early if stderr empty.
+
+            stderr_bytes = stderr_IO.read()
+            # line contents:
+            stderr = stderr_bytes.decode(defenc)
+            # git-checkout-index: this already exists
+            endings = (
+                " already exists",
+                " is not in the cache",
+                " does not exist at stage",
+                " is unmerged",
+            )
+            for line in stderr.splitlines():
+                if not line.startswith("git checkout-index: ") and not line.startswith("git-checkout-index: "):
+                    is_a_dir = " is a directory"
+                    unlink_issue = "unable to unlink old '"
+                    already_exists_issue = " already exists, no checkout"  # created by entry.c:checkout_entry(...)
+                    if line.endswith(is_a_dir):
+                        failed_files.append(line[: -len(is_a_dir)])
+                        failed_reasons.append(is_a_dir)
+                    elif line.startswith(unlink_issue):
+                        failed_files.append(line[len(unlink_issue) : line.rfind("'")])
+                        failed_reasons.append(unlink_issue)
+                    elif line.endswith(already_exists_issue):
+                        failed_files.append(line[: -len(already_exists_issue)])
+                        failed_reasons.append(already_exists_issue)
+                    else:
+                        unknown_lines.append(line)
+                    continue
+                # END special lines parsing
+
+                for e in endings:
+                    if line.endswith(e):
+                        failed_files.append(line[20 : -len(e)])
+                        failed_reasons.append(e)
+                        break
+                    # END if ending matches
+                # END for each possible ending
+            # END for each line
+            if unknown_lines:
+                raise GitCommandError(("git-checkout-index",), 128, stderr)
+            if failed_files:
+                valid_files = list(set(iter_checked_out_files) - set(failed_files))
+                raise CheckoutError(
+                    "Some files could not be checked out from the index due to local modifications",
+                    failed_files,
+                    valid_files,
+                    failed_reasons,
+                )
+
+        # END stderr handler
+
+        if paths is None:
+            args.append("--all")
+            kwargs["as_process"] = 1
+            fprogress(None, False, None)
+            proc = self.repo.git.checkout_index(*args, **kwargs)
+            proc.wait()
+            fprogress(None, True, None)
+            rval_iter = (e.path for e in self.entries.values())
+            handle_stderr(proc, rval_iter)
+            return rval_iter
+        else:
+            if isinstance(paths, str):
+                paths = [paths]
+
+            # Make sure we have our entries loaded before we start checkout_index, which
+            # will hold a lock on it. We try to get the lock as well during our entries
+            # initialization.
+            self.entries  # noqa: B018
+
+            args.append("--stdin")
+            kwargs["as_process"] = True
+            kwargs["istream"] = subprocess.PIPE
+            proc = self.repo.git.checkout_index(args, **kwargs)
+            # FIXME: Reading from GIL!
+            make_exc = lambda: GitCommandError(("git-checkout-index",) + tuple(args), 128, proc.stderr.read())
+            checked_out_files: List[PathLike] = []
+
+            for path in paths:
+                co_path = to_native_path_linux(self._to_relative_path(path))
+                # If the item is not in the index, it could be a directory.
+                path_is_directory = False
+
+                try:
+                    self.entries[(co_path, 0)]
+                except KeyError:
+                    folder = str(co_path)
+                    if not folder.endswith("/"):
+                        folder += "/"
+                    for entry in self.entries.values():
+                        if str(entry.path).startswith(folder):
+                            p = entry.path
+                            self._write_path_to_stdin(proc, p, p, make_exc, fprogress, read_from_stdout=False)
+                            checked_out_files.append(p)
+                            path_is_directory = True
+                        # END if entry is in directory
+                    # END for each entry
+                # END path exception handlnig
+
+                if not path_is_directory:
+                    self._write_path_to_stdin(proc, co_path, path, make_exc, fprogress, read_from_stdout=False)
+                    checked_out_files.append(co_path)
+                # END path is a file
+            # END for each path
+            try:
+                self._flush_stdin_and_wait(proc, ignore_stdout=True)
+            except GitCommandError:
+                # Without parsing stdout we don't know what failed.
+                raise CheckoutError(  # noqa: B904
+                    "Some files could not be checked out from the index, probably because they didn't exist.",
+                    failed_files,
+                    [],
+                    failed_reasons,
+                )
+
+            handle_stderr(proc, checked_out_files)
+            return checked_out_files
+        # END paths handling
+
+    @default_index
+    def reset(
+        self,
+        commit: Union[Commit, "Reference", str] = "HEAD",
+        working_tree: bool = False,
+        paths: Union[None, Iterable[PathLike]] = None,
+        head: bool = False,
+        **kwargs: Any,
+    ) -> "IndexFile":
+        """Reset the index to reflect the tree at the given commit. This will not adjust
+        our HEAD reference by default, as opposed to
+        :meth:`HEAD.reset <git.refs.head.HEAD.reset>`.
+
+        :param commit:
+            Revision, :class:`~git.refs.reference.Reference` or
+            :class:`~git.objects.commit.Commit` specifying the commit we should
+            represent.
+
+            If you want to specify a tree only, use :meth:`IndexFile.from_tree` and
+            overwrite the default index.
+
+        :param working_tree:
+            If ``True``, the files in the working tree will reflect the changed index.
+            If ``False``, the working tree will not be touched.
+            Please note that changes to the working copy will be discarded without
+            warning!
+
+        :param head:
+            If ``True``, the head will be set to the given commit. This is ``False`` by
+            default, but if ``True``, this method behaves like
+            :meth:`HEAD.reset <git.refs.head.HEAD.reset>`.
+
+        :param paths:
+            If given as an iterable of absolute or repository-relative paths, only these
+            will be reset to their state at the given commit-ish.
+            The paths need to exist at the commit, otherwise an exception will be
+            raised.
+
+        :param kwargs:
+            Additional keyword arguments passed to :manpage:`git-reset(1)`.
+
+        :note:
+            :meth:`IndexFile.reset`, as opposed to
+            :meth:`HEAD.reset <git.refs.head.HEAD.reset>`, will not delete any files in
+            order to maintain a consistent working tree. Instead, it will just check out
+            the files according to their state in the index.
+            If you want :manpage:`git-reset(1)`-like behaviour, use
+            :meth:`HEAD.reset <git.refs.head.HEAD.reset>` instead.
+
+        :return:
+            self
+        """
+        # What we actually want to do is to merge the tree into our existing index,
+        # which is what git-read-tree does.
+        new_inst = type(self).from_tree(self.repo, commit)
+        if not paths:
+            self.entries = new_inst.entries
+        else:
+            nie = new_inst.entries
+            for path in paths:
+                path = self._to_relative_path(path)
+                try:
+                    key = entry_key(path, 0)
+                    self.entries[key] = nie[key]
+                except KeyError:
+                    # If key is not in theirs, it mustn't be in ours.
+                    try:
+                        del self.entries[key]
+                    except KeyError:
+                        pass
+                    # END handle deletion keyerror
+                # END handle keyerror
+            # END for each path
+        # END handle paths
+        self.write()
+
+        if working_tree:
+            self.checkout(paths=paths, force=True)
+        # END handle working tree
+
+        if head:
+            self.repo.head.set_commit(self.repo.commit(commit), logmsg="%s: Updating HEAD" % commit)
+        # END handle head change
+
+        return self
+
+    # FIXME: This is documented to accept the same parameters as Diffable.diff, but this
+    # does not handle NULL_TREE for `other`. (The suppressed mypy error is about this.)
+    def diff(
+        self,
+        other: Union[  # type: ignore[override]
+            Literal[git_diff.DiffConstants.INDEX],
+            "Tree",
+            "Commit",
+            str,
+            None,
+        ] = git_diff.INDEX,
+        paths: Union[PathLike, List[PathLike], Tuple[PathLike, ...], None] = None,
+        create_patch: bool = False,
+        **kwargs: Any,
+    ) -> git_diff.DiffIndex[git_diff.Diff]:
+        """Diff this index against the working copy or a :class:`~git.objects.tree.Tree`
+        or :class:`~git.objects.commit.Commit` object.
+
+        For documentation of the parameters and return values, see
+        :meth:`Diffable.diff <git.diff.Diffable.diff>`.
+
+        :note:
+            Will only work with indices that represent the default git index as they
+            have not been initialized with a stream.
+        """
+        # Only run if we are the default repository index.
+        if self._file_path != self._index_path():
+            raise AssertionError("Cannot call %r on indices that do not represent the default git index" % self.diff())
+        # Index against index is always empty.
+        if other is self.INDEX:
+            return git_diff.DiffIndex()
+
+        # Index against anything but None is a reverse diff with the respective item.
+        # Handle existing -R flags properly.
+        # Transform strings to the object so that we can call diff on it.
+        if isinstance(other, str):
+            other = self.repo.rev_parse(other)
+        # END object conversion
+
+        if isinstance(other, Object):  # For Tree or Commit.
+            # Invert the existing R flag.
+            cur_val = kwargs.get("R", False)
+            kwargs["R"] = not cur_val
+            return other.diff(self.INDEX, paths, create_patch, **kwargs)
+        # END diff against other item handling
+
+        # If other is not None here, something is wrong.
+        if other is not None:
+            raise ValueError("other must be None, Diffable.INDEX, a Tree or Commit, was %r" % other)
+
+        # Diff against working copy - can be handled by superclass natively.
+        return super().diff(other, paths, create_patch, **kwargs)

venv/lib/python3.10/site-packages/git/index/fun.py

@@ -0,0 +1,465 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Standalone functions to accompany the index implementation and make it more
+versatile."""
+
+__all__ = [
+    "write_cache",
+    "read_cache",
+    "write_tree_from_cache",
+    "entry_key",
+    "stat_mode_to_index_mode",
+    "S_IFGITLINK",
+    "run_commit_hook",
+    "hook_path",
+]
+
+from io import BytesIO
+import os
+import os.path as osp
+from pathlib import Path
+from stat import S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, S_ISDIR, S_ISLNK, S_IXUSR
+import subprocess
+import sys
+
+from gitdb.base import IStream
+from gitdb.typ import str_tree_type
+
+from git.cmd import handle_process_output, safer_popen
+from git.compat import defenc, force_bytes, force_text, safe_decode
+from git.exc import HookExecutionError, UnmergedEntriesError
+from git.objects.fun import (
+    traverse_tree_recursive,
+    traverse_trees_recursive,
+    tree_to_stream,
+)
+from git.util import IndexFileSHA1Writer, finalize_process
+
+from .typ import BaseIndexEntry, IndexEntry, CE_NAMEMASK, CE_STAGESHIFT
+from .util import pack, unpack
+
+# typing -----------------------------------------------------------------------------
+
+from typing import Dict, IO, List, Sequence, TYPE_CHECKING, Tuple, Type, Union, cast
+
+from git.types import PathLike
+
+if TYPE_CHECKING:
+    from git.db import GitCmdObjectDB
+    from git.objects.tree import TreeCacheTup
+
+    from .base import IndexFile
+
+# ------------------------------------------------------------------------------------
+
+S_IFGITLINK = S_IFLNK | S_IFDIR
+"""Flags for a submodule."""
+
+CE_NAMEMASK_INV = ~CE_NAMEMASK
+
+
+def hook_path(name: str, git_dir: PathLike) -> str:
+    """:return: path to the given named hook in the given git repository directory"""
+    return osp.join(git_dir, "hooks", name)
+
+
+def _has_file_extension(path: str) -> str:
+    return osp.splitext(path)[1]
+
+
+def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
+    """Run the commit hook of the given name. Silently ignore hooks that do not exist.
+
+    :param name:
+        Name of hook, like ``pre-commit``.
+
+    :param index:
+        :class:`~git.index.base.IndexFile` instance.
+
+    :param args:
+        Arguments passed to hook file.
+
+    :raise git.exc.HookExecutionError:
+    """
+    hp = hook_path(name, index.repo.git_dir)
+    if not os.access(hp, os.X_OK):
+        return
+
+    env = os.environ.copy()
+    env["GIT_INDEX_FILE"] = safe_decode(str(index.path))
+    env["GIT_EDITOR"] = ":"
+    cmd = [hp]
+    try:
+        if sys.platform == "win32" and not _has_file_extension(hp):
+            # Windows only uses extensions to determine how to open files
+            # (doesn't understand shebangs). Try using bash to run the hook.
+            relative_hp = Path(hp).relative_to(index.repo.working_dir).as_posix()
+            cmd = ["bash.exe", relative_hp]
+
+        process = safer_popen(
+            cmd + list(args),
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=index.repo.working_dir,
+        )
+    except Exception as ex:
+        raise HookExecutionError(hp, ex) from ex
+    else:
+        stdout_list: List[str] = []
+        stderr_list: List[str] = []
+        handle_process_output(process, stdout_list.append, stderr_list.append, finalize_process)
+        stdout = "".join(stdout_list)
+        stderr = "".join(stderr_list)
+        if process.returncode != 0:
+            stdout = force_text(stdout, defenc)
+            stderr = force_text(stderr, defenc)
+            raise HookExecutionError(hp, process.returncode, stderr, stdout)
+    # END handle return code
+
+
+def stat_mode_to_index_mode(mode: int) -> int:
+    """Convert the given mode from a stat call to the corresponding index mode and
+    return it."""
+    if S_ISLNK(mode):  # symlinks
+        return S_IFLNK
+    if S_ISDIR(mode) or S_IFMT(mode) == S_IFGITLINK:  # submodules
+        return S_IFGITLINK
+    return S_IFREG | (mode & S_IXUSR and 0o755 or 0o644)  # blobs with or without executable bit
+
+
+def write_cache(
+    entries: Sequence[Union[BaseIndexEntry, "IndexEntry"]],
+    stream: IO[bytes],
+    extension_data: Union[None, bytes] = None,
+    ShaStreamCls: Type[IndexFileSHA1Writer] = IndexFileSHA1Writer,
+) -> None:
+    """Write the cache represented by entries to a stream.
+
+    :param entries:
+        **Sorted** list of entries.
+
+    :param stream:
+        Stream to wrap into the AdapterStreamCls - it is used for final output.
+
+    :param ShaStreamCls:
+        Type to use when writing to the stream. It produces a sha while writing to it,
+        before the data is passed on to the wrapped stream.
+
+    :param extension_data:
+        Any kind of data to write as a trailer, it must begin a 4 byte identifier,
+        followed by its size (4 bytes).
+    """
+    # Wrap the stream into a compatible writer.
+    stream_sha = ShaStreamCls(stream)
+
+    tell = stream_sha.tell
+    write = stream_sha.write
+
+    # Header
+    version = 2
+    write(b"DIRC")
+    write(pack(">LL", version, len(entries)))
+
+    # Body
+    for entry in entries:
+        beginoffset = tell()
+        write(entry.ctime_bytes)  # ctime
+        write(entry.mtime_bytes)  # mtime
+        path_str = str(entry.path)
+        path: bytes = force_bytes(path_str, encoding=defenc)
+        plen = len(path) & CE_NAMEMASK  # Path length
+        assert plen == len(path), "Path %s too long to fit into index" % entry.path
+        flags = plen | (entry.flags & CE_NAMEMASK_INV)  # Clear possible previous values.
+        write(
+            pack(
+                ">LLLLLL20sH",
+                entry.dev,
+                entry.inode,
+                entry.mode,
+                entry.uid,
+                entry.gid,
+                entry.size,
+                entry.binsha,
+                flags,
+            )
+        )
+        write(path)
+        real_size = (tell() - beginoffset + 8) & ~7
+        write(b"\0" * ((beginoffset + real_size) - tell()))
+    # END for each entry
+
+    # Write previously cached extensions data.
+    if extension_data is not None:
+        stream_sha.write(extension_data)
+
+    # Write the sha over the content.
+    stream_sha.write_sha()
+
+
+def read_header(stream: IO[bytes]) -> Tuple[int, int]:
+    """Return tuple(version_long, num_entries) from the given stream."""
+    type_id = stream.read(4)
+    if type_id != b"DIRC":
+        raise AssertionError("Invalid index file header: %r" % type_id)
+    unpacked = cast(Tuple[int, int], unpack(">LL", stream.read(4 * 2)))
+    version, num_entries = unpacked
+
+    # TODO: Handle version 3: extended data, see read-cache.c.
+    assert version in (1, 2)
+    return version, num_entries
+
+
+def entry_key(*entry: Union[BaseIndexEntry, PathLike, int]) -> Tuple[PathLike, int]:
+    """
+    :return:
+        Key suitable to be used for the
+        :attr:`index.entries <git.index.base.IndexFile.entries>` dictionary.
+
+    :param entry:
+        One instance of type BaseIndexEntry or the path and the stage.
+    """
+
+    # def is_entry_key_tup(entry_key: Tuple) -> TypeGuard[Tuple[PathLike, int]]:
+    #     return isinstance(entry_key, tuple) and len(entry_key) == 2
+
+    if len(entry) == 1:
+        entry_first = entry[0]
+        assert isinstance(entry_first, BaseIndexEntry)
+        return (entry_first.path, entry_first.stage)
+    else:
+        # assert is_entry_key_tup(entry)
+        entry = cast(Tuple[PathLike, int], entry)
+        return entry
+    # END handle entry
+
+
+def read_cache(
+    stream: IO[bytes],
+) -> Tuple[int, Dict[Tuple[PathLike, int], "IndexEntry"], bytes, bytes]:
+    """Read a cache file from the given stream.
+
+    :return:
+        tuple(version, entries_dict, extension_data, content_sha)
+
+        * *version* is the integer version number.
+        * *entries_dict* is a dictionary which maps IndexEntry instances to a path at a
+          stage.
+        * *extension_data* is ``""`` or 4 bytes of type + 4 bytes of size + size bytes.
+        * *content_sha* is a 20 byte sha on all cache file contents.
+    """
+    version, num_entries = read_header(stream)
+    count = 0
+    entries: Dict[Tuple[PathLike, int], "IndexEntry"] = {}
+
+    read = stream.read
+    tell = stream.tell
+    while count < num_entries:
+        beginoffset = tell()
+        ctime = unpack(">8s", read(8))[0]
+        mtime = unpack(">8s", read(8))[0]
+        (dev, ino, mode, uid, gid, size, sha, flags) = unpack(">LLLLLL20sH", read(20 + 4 * 6 + 2))
+        path_size = flags & CE_NAMEMASK
+        path = read(path_size).decode(defenc)
+
+        real_size = (tell() - beginoffset + 8) & ~7
+        read((beginoffset + real_size) - tell())
+        entry = IndexEntry((mode, sha, flags, path, ctime, mtime, dev, ino, uid, gid, size))
+        # entry_key would be the method to use, but we save the effort.
+        entries[(path, entry.stage)] = entry
+        count += 1
+    # END for each entry
+
+    # The footer contains extension data and a sha on the content so far.
+    # Keep the extension footer,and verify we have a sha in the end.
+    # Extension data format is:
+    #   4 bytes ID
+    #   4 bytes length of chunk
+    #   Repeated 0 - N times
+    extension_data = stream.read(~0)
+    assert len(extension_data) > 19, (
+        "Index Footer was not at least a sha on content as it was only %i bytes in size" % len(extension_data)
+    )
+
+    content_sha = extension_data[-20:]
+
+    # Truncate the sha in the end as we will dynamically create it anyway.
+    extension_data = extension_data[:-20]
+
+    return (version, entries, extension_data, content_sha)
+
+
+def write_tree_from_cache(
+    entries: List[IndexEntry], odb: "GitCmdObjectDB", sl: slice, si: int = 0
+) -> Tuple[bytes, List["TreeCacheTup"]]:
+    R"""Create a tree from the given sorted list of entries and put the respective
+    trees into the given object database.
+
+    :param entries:
+        **Sorted** list of :class:`~git.index.typ.IndexEntry`\s.
+
+    :param odb:
+        Object database to store the trees in.
+
+    :param si:
+        Start index at which we should start creating subtrees.
+
+    :param sl:
+        Slice indicating the range we should process on the entries list.
+
+    :return:
+        tuple(binsha, list(tree_entry, ...))
+
+        A tuple of a sha and a list of tree entries being a tuple of hexsha, mode, name.
+    """
+    tree_items: List["TreeCacheTup"] = []
+
+    ci = sl.start
+    end = sl.stop
+    while ci < end:
+        entry = entries[ci]
+        if entry.stage != 0:
+            raise UnmergedEntriesError(entry)
+        # END abort on unmerged
+        ci += 1
+        rbound = entry.path.find("/", si)
+        if rbound == -1:
+            # It's not a tree.
+            tree_items.append((entry.binsha, entry.mode, entry.path[si:]))
+        else:
+            # Find common base range.
+            base = entry.path[si:rbound]
+            xi = ci
+            while xi < end:
+                oentry = entries[xi]
+                orbound = oentry.path.find("/", si)
+                if orbound == -1 or oentry.path[si:orbound] != base:
+                    break
+                # END abort on base mismatch
+                xi += 1
+            # END find common base
+
+            # Enter recursion.
+            # ci - 1 as we want to count our current item as well.
+            sha, _tree_entry_list = write_tree_from_cache(entries, odb, slice(ci - 1, xi), rbound + 1)
+            tree_items.append((sha, S_IFDIR, base))
+
+            # Skip ahead.
+            ci = xi
+        # END handle bounds
+    # END for each entry
+
+    # Finally create the tree.
+    sio = BytesIO()
+    tree_to_stream(tree_items, sio.write)  # Writes to stream as bytes, but doesn't change tree_items.
+    sio.seek(0)
+
+    istream = odb.store(IStream(str_tree_type, len(sio.getvalue()), sio))
+    return (istream.binsha, tree_items)
+
+
+def _tree_entry_to_baseindexentry(tree_entry: "TreeCacheTup", stage: int) -> BaseIndexEntry:
+    return BaseIndexEntry((tree_entry[1], tree_entry[0], stage << CE_STAGESHIFT, tree_entry[2]))
+
+
+def aggressive_tree_merge(odb: "GitCmdObjectDB", tree_shas: Sequence[bytes]) -> List[BaseIndexEntry]:
+    R"""
+    :return:
+        List of :class:`~git.index.typ.BaseIndexEntry`\s representing the aggressive
+        merge of the given trees. All valid entries are on stage 0, whereas the
+        conflicting ones are left on stage 1, 2 or 3, whereas stage 1 corresponds to the
+        common ancestor tree, 2 to our tree and 3 to 'their' tree.
+
+    :param tree_shas:
+        1, 2 or 3 trees as identified by their binary 20 byte shas. If 1 or two, the
+        entries will effectively correspond to the last given tree. If 3 are given, a 3
+        way merge is performed.
+    """
+    out: List[BaseIndexEntry] = []
+
+    # One and two way is the same for us, as we don't have to handle an existing
+    # index, instrea
+    if len(tree_shas) in (1, 2):
+        for entry in traverse_tree_recursive(odb, tree_shas[-1], ""):
+            out.append(_tree_entry_to_baseindexentry(entry, 0))
+        # END for each entry
+        return out
+    # END handle single tree
+
+    if len(tree_shas) > 3:
+        raise ValueError("Cannot handle %i trees at once" % len(tree_shas))
+
+    # Three trees.
+    for base, ours, theirs in traverse_trees_recursive(odb, tree_shas, ""):
+        if base is not None:
+            # Base version exists.
+            if ours is not None:
+                # Ours exists.
+                if theirs is not None:
+                    # It exists in all branches. Ff it was changed in both
+                    # its a conflict. Otherwise, we take the changed version.
+                    # This should be the most common branch, so it comes first.
+                    if (base[0] != ours[0] and base[0] != theirs[0] and ours[0] != theirs[0]) or (
+                        base[1] != ours[1] and base[1] != theirs[1] and ours[1] != theirs[1]
+                    ):
+                        # Changed by both.
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(ours, 2))
+                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
+                    elif base[0] != ours[0] or base[1] != ours[1]:
+                        # Only we changed it.
+                        out.append(_tree_entry_to_baseindexentry(ours, 0))
+                    else:
+                        # Either nobody changed it, or they did. In either
+                        # case, use theirs.
+                        out.append(_tree_entry_to_baseindexentry(theirs, 0))
+                    # END handle modification
+                else:
+                    if ours[0] != base[0] or ours[1] != base[1]:
+                        # They deleted it, we changed it, conflict.
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(ours, 2))
+                    # else:
+                    #   # We didn't change it, ignore.
+                    #   pass
+                    # END handle our change
+                # END handle theirs
+            else:
+                if theirs is None:
+                    # Deleted in both, its fine - it's out.
+                    pass
+                else:
+                    if theirs[0] != base[0] or theirs[1] != base[1]:
+                        # Deleted in ours, changed theirs, conflict.
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
+                    # END theirs changed
+                    # else:
+                    #   # Theirs didn't change.
+                    #   pass
+                # END handle theirs
+            # END handle ours
+        else:
+            # All three can't be None.
+            if ours is None:
+                # Added in their branch.
+                assert theirs is not None
+                out.append(_tree_entry_to_baseindexentry(theirs, 0))
+            elif theirs is None:
+                # Added in our branch.
+                out.append(_tree_entry_to_baseindexentry(ours, 0))
+            else:
+                # Both have it, except for the base, see whether it changed.
+                if ours[0] != theirs[0] or ours[1] != theirs[1]:
+                    out.append(_tree_entry_to_baseindexentry(ours, 2))
+                    out.append(_tree_entry_to_baseindexentry(theirs, 3))
+                else:
+                    # It was added the same in both.
+                    out.append(_tree_entry_to_baseindexentry(ours, 0))
+                # END handle two items
+            # END handle heads
+        # END handle base exists
+    # END for each entries tuple
+
+    return out

venv/lib/python3.10/site-packages/github/CodeScanAlertInstance.py

@@ -0,0 +1,115 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2022 Eric Nieuwland <eric.nieuwland@gmail.com>                     #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import github.CodeScanAlertInstanceLocation
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+if TYPE_CHECKING:
+    from github.CodeScanAlertInstanceLocation import CodeScanAlertInstanceLocation
+
+
+class CodeScanAlertInstance(NonCompletableGithubObject):
+    """
+    This class represents code scanning alert instances.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/code-scanning.
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._analysis_key: Attribute[str] = NotSet
+        self._classifications: Attribute[list[str]] = NotSet
+        self._commit_sha: Attribute[str] = NotSet
+        self._environment: Attribute[str] = NotSet
+        self._location: Attribute[CodeScanAlertInstanceLocation] = NotSet
+        self._message: Attribute[dict[str, Any]] = NotSet
+        self._ref: Attribute[str] = NotSet
+        self._state: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"ref": self.ref, "analysis_key": self.analysis_key})
+
+    @property
+    def analysis_key(self) -> str:
+        return self._analysis_key.value
+
+    @property
+    def classifications(self) -> list[str]:
+        return self._classifications.value
+
+    @property
+    def commit_sha(self) -> str:
+        return self._commit_sha.value
+
+    @property
+    def environment(self) -> str:
+        return self._environment.value
+
+    @property
+    def location(self) -> CodeScanAlertInstanceLocation:
+        return self._location.value
+
+    @property
+    def message(self) -> dict[str, Any]:
+        return self._message.value
+
+    @property
+    def ref(self) -> str:
+        return self._ref.value
+
+    @property
+    def state(self) -> str:
+        return self._state.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "analysis_key" in attributes:  # pragma no branch
+            self._analysis_key = self._makeStringAttribute(attributes["analysis_key"])
+        if "classifications" in attributes:  # pragma no branch
+            self._classifications = self._makeListOfStringsAttribute(attributes["classifications"])
+        if "commit_sha" in attributes:  # pragma no branch
+            self._commit_sha = self._makeStringAttribute(attributes["commit_sha"])
+        if "environment" in attributes:  # pragma no branch
+            self._environment = self._makeStringAttribute(attributes["environment"])
+        if "environment" in attributes:  # pragma no branch
+            self._environment = self._makeStringAttribute(attributes["environment"])
+        if "location" in attributes:  # pragma no branch
+            self._location = self._makeClassAttribute(
+                github.CodeScanAlertInstanceLocation.CodeScanAlertInstanceLocation,
+                attributes["location"],
+            )
+        if "message" in attributes:  # pragma no branch
+            self._message = self._makeDictAttribute(attributes["message"])
+        if "ref" in attributes:  # pragma no branch
+            self._ref = self._makeStringAttribute(attributes["ref"])
+        if "state" in attributes:  # pragma no branch
+            self._state = self._makeStringAttribute(attributes["state"])

venv/lib/python3.10/site-packages/github/CodeScanAlertInstanceLocation.py

@@ -0,0 +1,95 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2020 Dhruv Manilawala <dhruvmanila@gmail.com>                      #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2022 Eric Nieuwland <eric.nieuwland@gmail.com>                     #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from typing import Any, Dict
+
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class CodeScanAlertInstanceLocation(NonCompletableGithubObject):
+    """
+    This class represents code scanning alert instance locations.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/code-scanning.
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._end_column: Attribute[int] = NotSet
+        self._end_line: Attribute[int] = NotSet
+        self._path: Attribute[str] = NotSet
+        self._start_column: Attribute[int] = NotSet
+        self._start_line: Attribute[int] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__(
+            {
+                "path": self.path,
+                "start_line": self.start_line,
+                "start_column": self.start_column,
+                "end_line": self.end_line,
+                "end_column": self.end_column,
+            }
+        )
+
+    def __str__(self) -> str:
+        return f"{self.path} @ l{self.start_line}:c{self.start_column}-l{self.end_line}:c{self.end_column}"
+
+    @property
+    def end_column(self) -> int:
+        return self._end_column.value
+
+    @property
+    def end_line(self) -> int:
+        return self._end_line.value
+
+    @property
+    def path(self) -> str:
+        return self._path.value
+
+    @property
+    def start_column(self) -> int:
+        return self._start_column.value
+
+    @property
+    def start_line(self) -> int:
+        return self._start_line.value
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "end_column" in attributes:  # pragma no branch
+            self._end_column = self._makeIntAttribute(attributes["end_column"])
+        if "end_line" in attributes:  # pragma no branch
+            self._end_line = self._makeIntAttribute(attributes["end_line"])
+        if "path" in attributes:  # pragma no branch
+            self._path = self._makeStringAttribute(attributes["path"])
+        if "start_column" in attributes:  # pragma no branch
+            self._start_column = self._makeIntAttribute(attributes["start_column"])
+        if "start_line" in attributes:  # pragma no branch
+            self._start_line = self._makeIntAttribute(attributes["start_line"])

venv/lib/python3.10/site-packages/github/CodeScanRule.py

@@ -0,0 +1,98 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2020 Victor Zeng <zacker150@users.noreply.github.com>              #
+# Copyright 2022 Eric Nieuwland <eric.nieuwland@gmail.com>                     #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import Any
+
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class CodeScanRule(NonCompletableGithubObject):
+    """
+    This class represents Alerts from code scanning.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/code-scanning.
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._description: Attribute[str] = NotSet
+        self._id: Attribute[str] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._security_severity_level: Attribute[str] = NotSet
+        self._severity: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self.id, "name": self.name})
+
+    @property
+    def description(self) -> str:
+        return self._description.value
+
+    @property
+    def id(self) -> str:
+        return self._id.value
+
+    @property
+    def name(self) -> str:
+        return self._name.value
+
+    @property
+    def security_severity_level(self) -> str:
+        return self._security_severity_level.value
+
+    @property
+    def severity(self) -> str:
+        return self._severity.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "description" in attributes:  # pragma no branch
+            self._description = self._makeStringAttribute(attributes["description"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeStringAttribute(attributes["id"])
+        if "name" in attributes:  # pragma no branch
+            self._name = self._makeStringAttribute(attributes["name"])
+        if "security_severity_level" in attributes:  # pragma no branch
+            self._security_severity_level = self._makeStringAttribute(attributes["security_severity_level"])
+        if "severity" in attributes:  # pragma no branch
+            self._severity = self._makeStringAttribute(attributes["severity"])

venv/lib/python3.10/site-packages/github/CodeScanTool.py

@@ -0,0 +1,87 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2022 Eric Nieuwland <eric.nieuwland@gmail.com>                     #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from typing import Any, Dict
+
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class CodeScanTool(NonCompletableGithubObject):
+    """
+    This class represents code scanning tools.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/code-scanning.
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._guid: Attribute[str] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._version: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__(
+            {
+                "guid": self.guid,
+                "name": self.name,
+                "version": self.version,
+            }
+        )
+
+    @property
+    def guid(self) -> str:
+        return self._guid.value
+
+    @property
+    def name(self) -> str:
+        return self._name.value
+
+    @property
+    def version(self) -> str:
+        return self._version.value
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "guid" in attributes:  # pragma no branch
+            self._guid = self._makeStringAttribute(attributes["guid"])
+        if "name" in attributes:  # pragma no branch
+            self._name = self._makeStringAttribute(attributes["name"])
+        if "version" in attributes:  # pragma no branch
+            self._version = self._makeStringAttribute(attributes["version"])

venv/lib/python3.10/site-packages/github/CodeSecurityConfig.py

@@ -0,0 +1,217 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2025 Bill Napier <napier@pobox.com>                                #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class CodeSecurityConfig(NonCompletableGithubObject):
+    """
+    This class represents Configurations for Code Security.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/code-security/configurations.
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._id: Attribute[int] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._advanced_security: Attribute[str] = NotSet
+        self._code_scanning_default_setup: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._dependabot_alerts: Attribute[str] = NotSet
+        self._dependabot_security_updates: Attribute[str] = NotSet
+        self._dependency_graph: Attribute[str] = NotSet
+        self._dependency_graph_autosubmit_action: Attribute[str] = NotSet
+        self._description: Attribute[str] = NotSet
+        self._enforcement: Attribute[str] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._private_vulnerability_reporting: Attribute[str] = NotSet
+        self._secret_scanning: Attribute[str] = NotSet
+        self._secret_scanning_delegated_bypass: Attribute[str] = NotSet
+        self._secret_scanning_non_provider_patterns: Attribute[str] = NotSet
+        self._secret_scanning_push_protection: Attribute[str] = NotSet
+        self._secret_scanning_validity_checks: Attribute[str] = NotSet
+        self._target_type: Attribute[str] = NotSet
+        self._url: Attribute[str] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__(
+            {
+                "id": self.id,
+                "name": self.name,
+                "description": self.description,
+            }
+        )
+
+    @property
+    def advanced_security(self) -> str:
+        return self._advanced_security.value
+
+    @property
+    def code_scanning_default_setup(self) -> str:
+        return self._code_scanning_default_setup.value
+
+    @property
+    def created_at(self) -> datetime:
+        return self._created_at.value
+
+    @property
+    def dependabot_alerts(self) -> str:
+        return self._dependabot_alerts.value
+
+    @property
+    def dependabot_security_updates(self) -> str:
+        return self._dependabot_security_updates.value
+
+    @property
+    def dependency_graph(self) -> str:
+        return self._dependency_graph.value
+
+    @property
+    def dependency_graph_autosubmit_action(self) -> str:
+        return self._dependency_graph_autosubmit_action.value
+
+    @property
+    def description(self) -> str:
+        return self._description.value
+
+    @property
+    def enforcement(self) -> str:
+        return self._enforcement.value
+
+    @property
+    def html_url(self) -> str:
+        return self._html_url.value
+
+    @property
+    def id(self) -> int:
+        return self._id.value
+
+    @property
+    def name(self) -> str:
+        return self._name.value
+
+    @property
+    def private_vulnerability_reporting(self) -> str:
+        return self._private_vulnerability_reporting.value
+
+    @property
+    def secret_scanning(self) -> str:
+        return self._secret_scanning.value
+
+    @property
+    def secret_scanning_delegated_bypass(self) -> str:
+        return self._secret_scanning_delegated_bypass.value
+
+    @property
+    def secret_scanning_non_provider_patterns(self) -> str:
+        return self._secret_scanning_non_provider_patterns.value
+
+    @property
+    def secret_scanning_push_protection(self) -> str:
+        return self._secret_scanning_push_protection.value
+
+    @property
+    def secret_scanning_validity_checks(self) -> str:
+        return self._secret_scanning_validity_checks.value
+
+    @property
+    def target_type(self) -> str:
+        return self._target_type.value
+
+    @property
+    def updated_at(self) -> datetime:
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "advanced_security" in attributes:  # pragma no branch
+            self._advanced_security = self._makeStringAttribute(attributes["advanced_security"])
+        if "code_scanning_default_setup" in attributes:  # pragma no branch
+            self._code_scanning_default_setup = self._makeStringAttribute(attributes["code_scanning_default_setup"])
+        if "created_at" in attributes:  # pragma no branch
+            assert attributes["created_at"] is None or isinstance(attributes["created_at"], str), attributes[
+                "created_at"
+            ]
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "dependabot_alerts" in attributes:  # pragma no branch
+            self._dependabot_alerts = self._makeStringAttribute(attributes["dependabot_alerts"])
+        if "dependabot_security_updates" in attributes:  # pragma no branch
+            self._dependabot_security_updates = self._makeStringAttribute(attributes["dependabot_security_updates"])
+        if "dependency_graph" in attributes:  # pragma no branch
+            self._dependency_graph = self._makeStringAttribute(attributes["dependency_graph"])
+        if "dependency_graph_autosubmit_action" in attributes:  # pragma no branch
+            self._dependency_graph_autosubmit_action = self._makeStringAttribute(
+                attributes["dependency_graph_autosubmit_action"]
+            )
+        if "description" in attributes:  # pragma no branch
+            self._description = self._makeStringAttribute(attributes["description"])
+        if "enforcement" in attributes:  # pragma no branch
+            self._enforcement = self._makeStringAttribute(attributes["enforcement"])
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "name" in attributes:  # pragma no branch
+            self._name = self._makeStringAttribute(attributes["name"])
+        if "private_vulnerability_reporting" in attributes:  # pragma no branch
+            self._private_vulnerability_reporting = self._makeStringAttribute(
+                attributes["private_vulnerability_reporting"]
+            )
+        if "secret_scanning" in attributes:  # pragma no branch
+            self._secret_scanning = self._makeStringAttribute(attributes["secret_scanning"])
+        if "secret_scanning_delegated_bypass" in attributes:  # pragma no branch
+            self._secret_scanning_delegated_bypass = self._makeStringAttribute(
+                attributes["secret_scanning_delegated_bypass"]
+            )
+        if "secret_scanning_non_provider_patterns" in attributes:  # pragma no branch
+            self._secret_scanning_non_provider_patterns = self._makeStringAttribute(
+                attributes["secret_scanning_non_provider_patterns"]
+            )
+        if "secret_scanning_push_protection" in attributes:  # pragma no branch
+            self._secret_scanning_push_protection = self._makeStringAttribute(
+                attributes["secret_scanning_push_protection"]
+            )
+        if "secret_scanning_validity_checks" in attributes:  # pragma no branch
+            self._secret_scanning_validity_checks = self._makeStringAttribute(
+                attributes["secret_scanning_validity_checks"]
+            )
+        if "target_type" in attributes:  # pragma no branch
+            self._target_type = self._makeStringAttribute(attributes["target_type"])
+        if "updated_at" in attributes:  # pragma no branch
+            assert attributes["updated_at"] is None or isinstance(attributes["updated_at"], str), attributes[
+                "updated_at"
+            ]
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/CodeSecurityConfigRepository.py

@@ -0,0 +1,68 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2024 Thomas Cooper <coopernetes@proton.me>                         #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import github.Repository
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+if TYPE_CHECKING:
+    from github.Repository import Repository
+
+
+class CodeSecurityConfigRepository(NonCompletableGithubObject):
+    """
+    This class represents CodeSecurityConfigRepository.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/code-security/configurations
+
+    The OpenAPI schema can be found at
+    - /components/schemas/code-security-configuration-repositories
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._repository: Attribute[Repository] = NotSet
+        self._status: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.repository.__repr__()
+
+    @property
+    def repository(self) -> Repository:
+        return self._repository.value
+
+    @property
+    def status(self) -> str:
+        return self._status.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "repository" in attributes:  # pragma no branch
+            self._repository = self._makeClassAttribute(github.Repository.Repository, attributes["repository"])
+        if "status" in attributes:  # pragma no branch
+            self._status = self._makeStringAttribute(attributes["status"])

venv/lib/python3.10/site-packages/github/Commit.py

@@ -0,0 +1,370 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2013 martinqt <m.ki2@laposte.net>                                  #
+# Copyright 2014 Andy Casey <acasey@mso.anu.edu.au>                            #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 John Eskew <jeskew@edx.org>                                   #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Danilo Martins <mawkee@gmail.com>                             #
+# Copyright 2020 Dhruv Manilawala <dhruvmanila@gmail.com>                      #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Mark Walker <mark.walker@realbuzz.com>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2024 iarspider <iarspider@gmail.com>                               #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2025 xmo-odoo <xmo@odoo.com>                                       #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import github.Branch
+import github.CheckRun
+import github.CheckSuite
+import github.CommitCombinedStatus
+import github.CommitComment
+import github.CommitStats
+import github.CommitStatus
+import github.File
+import github.GitCommit
+import github.NamedUser
+import github.PaginatedList
+import github.Repository
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet, Opt, is_optional
+from github.PaginatedList import PaginatedList
+
+if TYPE_CHECKING:
+    from github.Branch import Branch
+    from github.CheckRun import CheckRun
+    from github.CheckSuite import CheckSuite
+    from github.CommitCombinedStatus import CommitCombinedStatus
+    from github.CommitComment import CommitComment
+    from github.CommitStats import CommitStats
+    from github.CommitStatus import CommitStatus
+    from github.File import File
+    from github.GitCommit import GitCommit
+    from github.NamedUser import NamedUser
+    from github.PullRequest import PullRequest
+    from github.Repository import Repository
+
+
+class Commit(CompletableGithubObject):
+    """
+    This class represents Commits.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/commits/commits#get-a-commit-object
+
+    The OpenAPI schema can be found at
+    - /components/schemas/branch-short/properties/commit
+    - /components/schemas/commit
+    - /components/schemas/commit-search-result-item
+    - /components/schemas/commit-search-result-item/properties/parents/items
+    - /components/schemas/commit/properties/parents/items
+    - /components/schemas/short-branch/properties/commit
+    - /components/schemas/tag/properties/commit
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._author: Attribute[NamedUser] = NotSet
+        self._comments_url: Attribute[str] = NotSet
+        self._commit: Attribute[GitCommit] = NotSet
+        self._committer: Attribute[NamedUser] = NotSet
+        self._files: Attribute[list[File]] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._parents: Attribute[list[Commit]] = NotSet
+        self._repository: Attribute[Repository] = NotSet
+        self._score: Attribute[float] = NotSet
+        self._sha: Attribute[str] = NotSet
+        self._stats: Attribute[CommitStats] = NotSet
+        self._text_matches: Attribute[dict[str, Any]] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"sha": self._sha.value})
+
+    @property
+    def _identity(self) -> str:
+        return self.sha
+
+    @property
+    def author(self) -> NamedUser:
+        self._completeIfNotSet(self._author)
+        return self._author.value
+
+    @property
+    def comments_url(self) -> str:
+        self._completeIfNotSet(self._comments_url)
+        return self._comments_url.value
+
+    @property
+    def commit(self) -> GitCommit:
+        self._completeIfNotSet(self._commit)
+        return self._commit.value
+
+    @property
+    def committer(self) -> NamedUser:
+        self._completeIfNotSet(self._committer)
+        return self._committer.value
+
+    # This should be a method, but this used to be a property and cannot be changed without breaking user code
+    # TODO: remove @property on version 3
+    @property
+    def files(self) -> PaginatedList[File]:
+        return PaginatedList(
+            github.File.File,
+            self._requester,
+            self.url,
+            {},
+            headers=None,
+            list_item="files",
+            total_count_item="total_files",
+            firstData=self.raw_data,
+            firstHeaders=self.raw_headers,
+        )
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def parents(self) -> list[Commit]:
+        self._completeIfNotSet(self._parents)
+        return self._parents.value
+
+    @property
+    def repository(self) -> Repository:
+        self._completeIfNotSet(self._repository)
+        return self._repository.value
+
+    @property
+    def score(self) -> float:
+        self._completeIfNotSet(self._score)
+        return self._score.value
+
+    @property
+    def sha(self) -> str:
+        self._completeIfNotSet(self._sha)
+        return self._sha.value
+
+    @property
+    def stats(self) -> CommitStats:
+        self._completeIfNotSet(self._stats)
+        return self._stats.value
+
+    @property
+    def text_matches(self) -> dict[str, Any]:
+        self._completeIfNotSet(self._text_matches)
+        return self._text_matches.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def create_comment(
+        self,
+        body: str,
+        line: Opt[int] = NotSet,
+        path: Opt[str] = NotSet,
+        position: Opt[int] = NotSet,
+    ) -> CommitComment:
+        """
+        :calls: `POST /repos/{owner}/{repo}/commits/{sha}/comments <https://docs.github.com/en/rest/reference/repos#comments>`_
+        """
+        assert isinstance(body, str), body
+        assert is_optional(line, int), line
+        assert is_optional(path, str), path
+        assert is_optional(position, int), position
+        post_parameters = NotSet.remove_unset_items({"body": body, "line": line, "path": path, "position": position})
+
+        headers, data = self._requester.requestJsonAndCheck("POST", f"{self.url}/comments", input=post_parameters)
+        return github.CommitComment.CommitComment(self._requester, headers, data, completed=True)
+
+    def create_status(
+        self,
+        state: str,
+        target_url: Opt[str] = NotSet,
+        description: Opt[str] = NotSet,
+        context: Opt[str] = NotSet,
+    ) -> CommitStatus:
+        """
+        :calls: `POST /repos/{owner}/{repo}/statuses/{sha} <https://docs.github.com/en/rest/reference/repos#statuses>`_
+        """
+        assert isinstance(state, str), state
+        assert is_optional(target_url, str), target_url
+        assert is_optional(description, str), description
+        assert is_optional(context, str), context
+        post_parameters = NotSet.remove_unset_items(
+            {
+                "state": state,
+                "target_url": target_url,
+                "description": description,
+                "context": context,
+            }
+        )
+
+        headers, data = self._requester.requestJsonAndCheck(
+            "POST",
+            f"{self._parentUrl(self._parentUrl(self.url))}/statuses/{self.sha}",
+            input=post_parameters,
+        )
+        return github.CommitStatus.CommitStatus(self._requester, headers, data)
+
+    def get_branches_where_head(self) -> list[Branch]:
+        """
+        :calls: `GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head <https://docs.github.com/rest/commits/commits#list-branches-for-head-commit>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("GET", f"{self.url}/branches-where-head")
+        return [github.Branch.Branch(self._requester, headers, item) for item in data]
+
+    def get_comments(self) -> PaginatedList[CommitComment]:
+        """
+        :calls: `GET /repos/{owner}/{repo}/commits/{sha}/comments <https://docs.github.com/en/rest/reference/repos#comments>`_
+        """
+        return PaginatedList(
+            github.CommitComment.CommitComment,
+            self._requester,
+            f"{self.url}/comments",
+            None,
+        )
+
+    def get_statuses(self) -> PaginatedList[CommitStatus]:
+        """
+        :calls: `GET /repos/{owner}/{repo}/statuses/{ref} <https://docs.github.com/en/rest/reference/repos#statuses>`_
+        """
+        return PaginatedList(
+            github.CommitStatus.CommitStatus,
+            self._requester,
+            f"{self._parentUrl(self._parentUrl(self.url))}/statuses/{self.sha}",
+            None,
+        )
+
+    def get_combined_status(self) -> CommitCombinedStatus:
+        """
+        :calls: `GET /repos/{owner}/{repo}/commits/{ref}/status/ <http://docs.github.com/en/rest/reference/repos#statuses>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("GET", f"{self.url}/status")
+        return github.CommitCombinedStatus.CommitCombinedStatus(self._requester, headers, data)
+
+    def get_pulls(self) -> PaginatedList[PullRequest]:
+        """
+        :calls: `GET /repos/{owner}/{repo}/commits/{sha}/pulls <https://docs.github.com/en/rest/reference/repos#list-pull-requests-associated-with-a-commit>`_
+        """
+        return PaginatedList(
+            github.PullRequest.PullRequest,
+            self._requester,
+            f"{self.url}/pulls",
+            None,
+            headers={"Accept": "application/vnd.github.groot-preview+json"},
+        )
+
+    def get_check_runs(
+        self,
+        check_name: Opt[str] = NotSet,
+        status: Opt[str] = NotSet,
+        filter: Opt[str] = NotSet,
+    ) -> PaginatedList[CheckRun]:
+        """
+        :calls: `GET /repos/{owner}/{repo}/commits/{sha}/check-runs <https://docs.github.com/en/rest/reference/checks#list-check-runs-for-a-git-reference>`_
+        """
+        assert is_optional(check_name, str), check_name
+        assert is_optional(status, str), status
+        assert is_optional(filter, str), filter
+        url_parameters = NotSet.remove_unset_items({"check_name": check_name, "status": status, "filter": filter})
+
+        return PaginatedList(
+            github.CheckRun.CheckRun,
+            self._requester,
+            f"{self.url}/check-runs",
+            url_parameters,
+            headers={"Accept": "application/vnd.github.v3+json"},
+            list_item="check_runs",
+        )
+
+    def get_check_suites(self, app_id: Opt[int] = NotSet, check_name: Opt[str] = NotSet) -> PaginatedList[CheckSuite]:
+        """
+        :class: `GET /repos/{owner}/{repo}/commits/{ref}/check-suites <https://docs.github.com/en/rest/reference/checks#list-check-suites-for-a-git-reference>`_
+        """
+        assert is_optional(app_id, int), app_id
+        assert is_optional(check_name, str), check_name
+        parameters = NotSet.remove_unset_items({"app_id": app_id, "check_name": check_name})
+
+        request_headers = {"Accept": "application/vnd.github.v3+json"}
+        return PaginatedList(
+            github.CheckSuite.CheckSuite,
+            self._requester,
+            f"{self.url}/check-suites",
+            parameters,
+            headers=request_headers,
+            list_item="check_suites",
+        )
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "author" in attributes:  # pragma no branch
+            self._author = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["author"])
+        if "comments_url" in attributes:  # pragma no branch
+            self._comments_url = self._makeStringAttribute(attributes["comments_url"])
+        if "commit" in attributes:  # pragma no branch
+            self._commit = self._makeClassAttribute(github.GitCommit.GitCommit, attributes["commit"])
+        if "committer" in attributes:  # pragma no branch
+            self._committer = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["committer"])
+        if "files" in attributes:  # pragma no branch
+            self._files = self._makeListOfClassesAttribute(github.File.File, attributes["files"])
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "parents" in attributes:  # pragma no branch
+            self._parents = self._makeListOfClassesAttribute(Commit, attributes["parents"])
+        if "repository" in attributes:  # pragma no branch
+            self._repository = self._makeClassAttribute(github.Repository.Repository, attributes["repository"])
+        if "score" in attributes:  # pragma no branch
+            self._score = self._makeFloatAttribute(attributes["score"])
+        if "sha" in attributes:  # pragma no branch
+            self._sha = self._makeStringAttribute(attributes["sha"])
+        if "stats" in attributes:  # pragma no branch
+            self._stats = self._makeClassAttribute(github.CommitStats.CommitStats, attributes["stats"])
+        if "text_matches" in attributes:  # pragma no branch
+            self._text_matches = self._makeDictAttribute(attributes["text_matches"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/CommitCombinedStatus.py

@@ -0,0 +1,114 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 John Eskew <jeskew@edx.org>                                   #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import Any
+
+import github.CommitStatus
+import github.Repository
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class CommitCombinedStatus(NonCompletableGithubObject):
+    """
+    This class represents CommitCombinedStatuses.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/repos#statuses
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._commit_url: Attribute[str] = NotSet
+        self._repository: Attribute[github.Repository.Repository] = NotSet
+        self._sha: Attribute[str] = NotSet
+        self._state: Attribute[str] = NotSet
+        self._statuses: Attribute[list[github.CommitStatus.CommitStatus]] = NotSet
+        self._total_count: Attribute[int] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"sha": self._sha.value, "state": self._state.value})
+
+    @property
+    def commit_url(self) -> str:
+        return self._commit_url.value
+
+    @property
+    def repository(self) -> github.Repository.Repository:
+        return self._repository.value
+
+    @property
+    def sha(self) -> str:
+        return self._sha.value
+
+    @property
+    def state(self) -> str:
+        return self._state.value
+
+    @property
+    def statuses(self) -> list[github.CommitStatus.CommitStatus]:
+        return self._statuses.value
+
+    @property
+    def total_count(self) -> int:
+        return self._total_count.value
+
+    @property
+    def url(self) -> str:
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "commit_url" in attributes:  # pragma no branch
+            self._commit_url = self._makeStringAttribute(attributes["commit_url"])
+        if "repository" in attributes:  # pragma no branch
+            self._repository = self._makeClassAttribute(github.Repository.Repository, attributes["repository"])
+        if "sha" in attributes:  # pragma no branch
+            self._sha = self._makeStringAttribute(attributes["sha"])
+        if "state" in attributes:  # pragma no branch
+            self._state = self._makeStringAttribute(attributes["state"])
+        if "statuses" in attributes:  # pragma no branch
+            self._statuses = self._makeListOfClassesAttribute(github.CommitStatus.CommitStatus, attributes["statuses"])
+        if "total_count" in attributes:  # pragma no branch
+            self._total_count = self._makeIntAttribute(attributes["total_count"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/CommitComment.py

@@ -0,0 +1,253 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2017 Nicolas Agustín Torres <nicolastrres@gmail.com>               #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 per1234 <accounts@perglass.com>                               #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Huan-Cheng Chang <changhc84@gmail.com>                        #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Mark Walker <mark.walker@realbuzz.com>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import github.GithubObject
+import github.NamedUser
+from github import Consts
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+from github.PaginatedList import PaginatedList
+
+if TYPE_CHECKING:
+    from github.Reaction import Reaction
+
+
+class CommitComment(CompletableGithubObject):
+    """
+    This class represents CommitComments.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/repos#comments
+
+    The OpenAPI schema can be found at
+    - /components/schemas/commit-comment
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._author_association: Attribute[str] = NotSet
+        self._body: Attribute[str] = NotSet
+        self._commit_id: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._id: Attribute[int] = NotSet
+        self._line: Attribute[int] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._path: Attribute[str] = NotSet
+        self._position: Attribute[int] = NotSet
+        self._reactions: Attribute[dict[str, Any]] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+        self._user: Attribute[github.NamedUser.NamedUser] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value, "user": self.user})
+
+    @property
+    def author_association(self) -> str:
+        self._completeIfNotSet(self._author_association)
+        return self._author_association.value
+
+    @property
+    def body(self) -> str:
+        self._completeIfNotSet(self._body)
+        return self._body.value
+
+    @property
+    def commit_id(self) -> str:
+        self._completeIfNotSet(self._commit_id)
+        return self._commit_id.value
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def id(self) -> int:
+        self._completeIfNotSet(self._id)
+        return self._id.value
+
+    @property
+    def line(self) -> int:
+        self._completeIfNotSet(self._line)
+        return self._line.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def path(self) -> str:
+        self._completeIfNotSet(self._path)
+        return self._path.value
+
+    @property
+    def position(self) -> int:
+        self._completeIfNotSet(self._position)
+        return self._position.value
+
+    @property
+    def reactions(self) -> dict[str, Any]:
+        self._completeIfNotSet(self._reactions)
+        return self._reactions.value
+
+    @property
+    def updated_at(self) -> datetime:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    @property
+    def user(self) -> github.NamedUser.NamedUser:
+        self._completeIfNotSet(self._user)
+        return self._user.value
+
+    def delete(self) -> None:
+        """
+        :calls: `DELETE /repos/{owner}/{repo}/comments/{id} <https://docs.github.com/en/rest/reference/repos#comments>`_
+        :rtype: None
+        """
+        headers, data = self._requester.requestJsonAndCheck("DELETE", self.url)
+
+    def edit(self, body: str) -> None:
+        """
+        :calls: `PATCH /repos/{owner}/{repo}/comments/{id} <https://docs.github.com/en/rest/reference/repos#comments>`_
+        """
+        assert isinstance(body, str), body
+        post_parameters = {
+            "body": body,
+        }
+        headers, data = self._requester.requestJsonAndCheck("PATCH", self.url, input=post_parameters)
+        self._useAttributes(data)
+
+    def get_reactions(self) -> PaginatedList[Reaction]:
+        """
+        :calls: `GET /repos/{owner}/{repo}/comments/{id}/reactions
+                <https://docs.github.com/en/rest/reference/reactions#list-reactions-for-a-commit-comment>`_
+        :return: :class: :class:`github.PaginatedList.PaginatedList` of :class:`github.Reaction.Reaction`
+        """
+        return PaginatedList(
+            github.Reaction.Reaction,
+            self._requester,
+            f"{self.url}/reactions",
+            None,
+            headers={"Accept": Consts.mediaTypeReactionsPreview},
+        )
+
+    def create_reaction(self, reaction_type: str) -> Reaction:
+        """
+        :calls: `POST /repos/{owner}/{repo}/comments/{id}/reactions
+                <https://docs.github.com/en/rest/reference/reactions#create-reaction-for-a-commit-comment>`_
+        """
+        assert isinstance(reaction_type, str), reaction_type
+        post_parameters = {
+            "content": reaction_type,
+        }
+        headers, data = self._requester.requestJsonAndCheck(
+            "POST",
+            f"{self.url}/reactions",
+            input=post_parameters,
+            headers={"Accept": Consts.mediaTypeReactionsPreview},
+        )
+        return github.Reaction.Reaction(self._requester, headers, data, completed=True)
+
+    def delete_reaction(self, reaction_id: int) -> bool:
+        """
+        :calls: `DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}
+                <https://docs.github.com/en/rest/reference/reactions#delete-a-commit-comment-reaction>`_
+        :param reaction_id: integer
+        :rtype: bool
+        """
+        assert isinstance(reaction_id, int), reaction_id
+        status, _, _ = self._requester.requestJson(
+            "DELETE",
+            f"{self.url}/reactions/{reaction_id}",
+            headers={"Accept": Consts.mediaTypeReactionsPreview},
+        )
+        return status == 204
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "author_association" in attributes:  # pragma no branch
+            self._author_association = self._makeStringAttribute(attributes["author_association"])
+        if "body" in attributes:  # pragma no branch
+            self._body = self._makeStringAttribute(attributes["body"])
+        if "commit_id" in attributes:  # pragma no branch
+            self._commit_id = self._makeStringAttribute(attributes["commit_id"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "line" in attributes:  # pragma no branch
+            self._line = self._makeIntAttribute(attributes["line"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "path" in attributes:  # pragma no branch
+            self._path = self._makeStringAttribute(attributes["path"])
+        if "position" in attributes:  # pragma no branch
+            self._position = self._makeIntAttribute(attributes["position"])
+        if "reactions" in attributes:  # pragma no branch
+            self._reactions = self._makeDictAttribute(attributes["reactions"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])
+        if "user" in attributes:  # pragma no branch
+            self._user = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["user"])

venv/lib/python3.10/site-packages/github/CommitStats.py

@@ -0,0 +1,74 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from typing import Any, Dict
+
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class CommitStats(NonCompletableGithubObject):
+    """
+    This class represents CommitStats.
+
+    The OpenAPI schema can be found at
+    - /components/schemas/commit/properties/stats
+    - /components/schemas/gist-history/properties/change_status
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._additions: Attribute[int] = NotSet
+        self._deletions: Attribute[int] = NotSet
+        self._total: Attribute[int] = NotSet
+
+    @property
+    def additions(self) -> int:
+        return self._additions.value
+
+    @property
+    def deletions(self) -> int:
+        return self._deletions.value
+
+    @property
+    def total(self) -> int:
+        return self._total.value
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "additions" in attributes:  # pragma no branch
+            self._additions = self._makeIntAttribute(attributes["additions"])
+        if "deletions" in attributes:  # pragma no branch
+            self._deletions = self._makeIntAttribute(attributes["deletions"])
+        if "total" in attributes:  # pragma no branch
+            self._total = self._makeIntAttribute(attributes["total"])

venv/lib/python3.10/site-packages/github/CommitStatus.py

@@ -0,0 +1,148 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2015 Matt Babineau <mbabineau@dataxu.com>                          #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Martijn Koster <mak-github@greenhills.co.uk>                  #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import github.GithubObject
+import github.NamedUser
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class CommitStatus(NonCompletableGithubObject):
+    """
+    This class represents CommitStatuses.The reference can be found here https://docs.github.com/en/rest/reference/repos#statuses
+
+    The OpenAPI schema can be found at
+    - /components/schemas/status
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._avatar_url: Attribute[str] = NotSet
+        self._context: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._creator: Attribute[github.NamedUser.NamedUser] = NotSet
+        self._description: Attribute[str] = NotSet
+        self._id: Attribute[int] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._state: Attribute[str] = NotSet
+        self._target_url: Attribute[str] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__(
+            {
+                "id": self._id.value,
+                "state": self._state.value,
+                "context": self._context.value,
+            }
+        )
+
+    @property
+    def avatar_url(self) -> str:
+        return self._avatar_url.value
+
+    @property
+    def context(self) -> str:
+        return self._context.value
+
+    @property
+    def created_at(self) -> datetime:
+        return self._created_at.value
+
+    @property
+    def creator(self) -> github.NamedUser.NamedUser:
+        return self._creator.value
+
+    @property
+    def description(self) -> str:
+        return self._description.value
+
+    @property
+    def id(self) -> int:
+        return self._id.value
+
+    @property
+    def node_id(self) -> str:
+        return self._node_id.value
+
+    @property
+    def state(self) -> str:
+        return self._state.value
+
+    @property
+    def target_url(self) -> str:
+        return self._target_url.value
+
+    @property
+    def updated_at(self) -> datetime:
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "avatar_url" in attributes:  # pragma no branch
+            self._avatar_url = self._makeStringAttribute(attributes["avatar_url"])
+        if "context" in attributes:  # pragma no branch
+            self._context = self._makeStringAttribute(attributes["context"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "creator" in attributes:  # pragma no branch
+            self._creator = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["creator"])
+        if "description" in attributes:  # pragma no branch
+            self._description = self._makeStringAttribute(attributes["description"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "state" in attributes:  # pragma no branch
+            self._state = self._makeStringAttribute(attributes["state"])
+        if "target_url" in attributes:  # pragma no branch
+            self._target_url = self._makeStringAttribute(attributes["target_url"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/Comparison.py

@@ -0,0 +1,170 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import Any
+
+import github.Commit
+import github.File
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+from github.PaginatedList import PaginatedList
+
+
+class Comparison(CompletableGithubObject):
+    """
+    This class represents Comparisons.
+    """
+
+    def _initAttributes(self) -> None:
+        self._ahead_by: Attribute[int] = NotSet
+        self._base_commit: Attribute[github.Commit.Commit] = NotSet
+        self._behind_by: Attribute[int] = NotSet
+        self._diff_url: Attribute[str] = NotSet
+        self._files: Attribute[list[github.File.File]] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._merge_base_commit: Attribute[github.Commit.Commit] = NotSet
+        self._patch_url: Attribute[str] = NotSet
+        self._permalink_url: Attribute[str] = NotSet
+        self._status: Attribute[str] = NotSet
+        self._total_commits: Attribute[int] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"url": self._url.value})
+
+    @property
+    def ahead_by(self) -> int:
+        self._completeIfNotSet(self._ahead_by)
+        return self._ahead_by.value
+
+    @property
+    def base_commit(self) -> github.Commit.Commit:
+        self._completeIfNotSet(self._base_commit)
+        return self._base_commit.value
+
+    @property
+    def behind_by(self) -> int:
+        self._completeIfNotSet(self._behind_by)
+        return self._behind_by.value
+
+    # This should be a method, but this used to be a property and cannot be changed without breaking user code
+    # TODO: remove @property on version 3
+    @property
+    def commits(self) -> PaginatedList[github.Commit.Commit]:
+        return PaginatedList(
+            github.Commit.Commit,
+            self._requester,
+            self.url,
+            {},
+            headers=None,
+            list_item="commits",
+            total_count_item="total_commits",
+            firstData=self.raw_data,
+            firstHeaders=self.raw_headers,
+        )
+
+    @property
+    def diff_url(self) -> str:
+        self._completeIfNotSet(self._diff_url)
+        return self._diff_url.value
+
+    @property
+    def files(self) -> list[github.File.File]:
+        self._completeIfNotSet(self._files)
+        return self._files.value
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def merge_base_commit(self) -> github.Commit.Commit:
+        self._completeIfNotSet(self._merge_base_commit)
+        return self._merge_base_commit.value
+
+    @property
+    def patch_url(self) -> str:
+        self._completeIfNotSet(self._patch_url)
+        return self._patch_url.value
+
+    @property
+    def permalink_url(self) -> str:
+        self._completeIfNotSet(self._permalink_url)
+        return self._permalink_url.value
+
+    @property
+    def status(self) -> str:
+        self._completeIfNotSet(self._status)
+        return self._status.value
+
+    @property
+    def total_commits(self) -> int:
+        self._completeIfNotSet(self._total_commits)
+        return self._total_commits.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "ahead_by" in attributes:  # pragma no branch
+            self._ahead_by = self._makeIntAttribute(attributes["ahead_by"])
+        if "base_commit" in attributes:  # pragma no branch
+            self._base_commit = self._makeClassAttribute(github.Commit.Commit, attributes["base_commit"])
+        if "behind_by" in attributes:  # pragma no branch
+            self._behind_by = self._makeIntAttribute(attributes["behind_by"])
+        if "diff_url" in attributes:  # pragma no branch
+            self._diff_url = self._makeStringAttribute(attributes["diff_url"])
+        if "files" in attributes:  # pragma no branch
+            self._files = self._makeListOfClassesAttribute(github.File.File, attributes["files"])
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "merge_base_commit" in attributes:  # pragma no branch
+            self._merge_base_commit = self._makeClassAttribute(github.Commit.Commit, attributes["merge_base_commit"])
+        if "patch_url" in attributes:  # pragma no branch
+            self._patch_url = self._makeStringAttribute(attributes["patch_url"])
+        if "permalink_url" in attributes:  # pragma no branch
+            self._permalink_url = self._makeStringAttribute(attributes["permalink_url"])
+        if "status" in attributes:  # pragma no branch
+            self._status = self._makeStringAttribute(attributes["status"])
+        if "total_commits" in attributes:  # pragma no branch
+            self._total_commits = self._makeIntAttribute(attributes["total_commits"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/Consts.py

@@ -0,0 +1,181 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jakub Wilk <jwilk@jwilk.net>                                  #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Aaron L. Levine <allevin@sandia.gov>                          #
+# Copyright 2018 Alice GIRARD <bouhahah@gmail.com>                             #
+# Copyright 2018 Maarten Fonville <mfonville@users.noreply.github.com>         #
+# Copyright 2018 Shubham Singh <41840111+singh811@users.noreply.github.com>    #
+# Copyright 2018 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 Yossarian King <yggy@blackbirdinteractive.com>                #
+# Copyright 2018 h.shi <10385628+AnYeMoWang@users.noreply.github.com>          #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Adam Baratz <adam.baratz@gmail.com>                           #
+# Copyright 2019 Nick Campbell <nicholas.j.campbell@gmail.com>                 #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Tim Gates <tim.gates@iress.com>                               #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2019 Will Li <cuichen.li94@gmail.com>                              #
+# Copyright 2020 Adrian Bridgett <58699309+tl-adrian-bridgett@users.noreply.github.com>#
+# Copyright 2020 Anuj Bansal <bansalanuj1996@gmail.com>                        #
+# Copyright 2020 Colby Gallup <colbygallup@gmail.com>                          #
+# Copyright 2020 Pascal Hofmann <mail@pascalhofmann.de>                        #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Tanner <51724788+lightningboltemoji@users.noreply.github.com> #
+# Copyright 2022 KimSia Sim <245021+simkimsia@users.noreply.github.com>        #
+# Copyright 2023 Denis Blanchette <dblanchette@coveo.com>                      #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+
+REQ_IF_NONE_MATCH = "If-None-Match"
+REQ_IF_MODIFIED_SINCE = "If-Modified-Since"
+PROCESSING_202_WAIT_TIME = 2
+
+# ##############################################################################
+# Response Header                                                              #
+# (Lower Case)                                                                 #
+# ##############################################################################
+RES_ETAG = "etag"
+RES_LAST_MODIFIED = "last-modified"
+
+# Inspired by https://github.com/google/go-github
+
+# Headers
+
+headerRateLimit = "x-ratelimit-limit"
+headerRateRemaining = "x-ratelimit-remaining"
+headerRateReset = "x-ratelimit-reset"
+headerOAuthScopes = "x-oauth-scopes"
+headerOTP = "x-github-otp"
+
+defaultMediaType = "application/octet-stream"
+
+# Custom media type for preview API
+
+# https://developer.github.com/changes/2014-12-09-new-attributes-for-stars-api/
+mediaTypeStarringPreview = "application/vnd.github.v3.star+json"
+
+# https://developer.github.com/changes/2016-02-19-source-import-preview-api/
+mediaTypeImportPreview = "application/vnd.github.barred-rock-preview"
+
+# https://developer.github.com/changes/2016-05-12-reactions-api-preview/
+mediaTypeReactionsPreview = "application/vnd.github.squirrel-girl-preview"
+
+# https://developer.github.com/changes/2016-09-14-Integrations-Early-Access/
+mediaTypeIntegrationPreview = "application/vnd.github.machine-man-preview+json"
+
+# https://developer.github.com/changes/2016-09-14-projects-api/
+mediaTypeProjectsPreview = "application/vnd.github.inertia-preview+json"
+
+# https://developer.github.com/changes/2017-01-05-commit-search-api/
+mediaTypeCommitSearchPreview = "application/vnd.github.cloak-preview"
+
+# https://developer.github.com/changes/2017-02-28-user-blocking-apis-and-webhook/
+mediaTypeBlockUsersPreview = "application/vnd.github.giant-sentry-fist-preview+json"
+
+# https://developer.github.com/changes/2017-07-17-update-topics-on-repositories/
+mediaTypeTopicsPreview = "application/vnd.github.mercy-preview+json"
+
+# https://developer.github.com/changes/2018-02-22-label-description-search-preview/
+mediaTypeLabelDescriptionSearchPreview = "application/vnd.github.symmetra-preview+json"
+
+# https://developer.github.com/changes/2018-01-10-lock-reason-api-preview/
+mediaTypeLockReasonPreview = "application/vnd.github.sailor-v-preview+json"
+
+# https://developer.github.com/changes/2018-01-25-organization-invitation-api-preview/
+mediaTypeOrganizationInvitationPreview = "application/vnd.github.dazzler-preview+json"
+
+# https://developer.github.com/changes/2018-02-07-team-discussions-api
+mediaTypeTeamDiscussionsPreview = "application/vnd.github.echo-preview+json"
+
+# https://developer.github.com/changes/2018-03-16-protected-branches-required-approving-reviews/
+mediaTypeRequireMultipleApprovingReviews = "application/vnd.github.luke-cage-preview+json"
+
+# https://developer.github.com/changes/2018-05-24-user-migration-api/
+mediaTypeMigrationPreview = "application/vnd.github.wyandotte-preview+json"
+
+# https://developer.github.com/changes/2019-07-16-repository-templates-api/
+mediaTypeTemplatesPreview = "application/vnd.github.baptiste-preview+json"
+
+# https://docs.github.com/en/rest/reference/search#highlighting-code-search-results-1
+highLightSearchPreview = "application/vnd.github.v3.text-match+json"
+
+# https://developer.github.com/changes/2018-02-22-protected-branches-required-signatures/
+signaturesProtectedBranchesPreview = "application/vnd.github.zzzax-preview+json"
+
+# https://developer.github.com/changes/2019-04-24-vulnerability-alerts/
+vulnerabilityAlertsPreview = "application/vnd.github.dorian-preview+json"
+
+# https://developer.github.com/changes/2019-06-04-automated-security-fixes/
+automatedSecurityFixes = "application/vnd.github.london-preview+json"
+
+# https://developer.github.com/changes/2019-05-29-update-branch-api/
+updateBranchPreview = "application/vnd.github.lydian-preview+json"
+
+# https://developer.github.com/changes/2016-05-23-timeline-preview-api/
+issueTimelineEventsPreview = "application/vnd.github.mockingbird-preview"
+
+# https://docs.github.com/en/rest/reference/teams#check-if-a-team-manages-a-repository
+teamRepositoryPermissions = "application/vnd.github.v3.repository+json"
+
+# https://developer.github.com/changes/2016-04-06-deployment-and-deployment-status-enhancements/
+deploymentEnhancementsPreview = "application/vnd.github.ant-man-preview+json"
+
+# https://developer.github.com/changes/2018-10-16-deployments-environments-states-and-auto-inactive-updates/
+deploymentStatusEnhancementsPreview = "application/vnd.github.flash-preview+json"
+
+# https://developer.github.com/changes/2019-12-03-internal-visibility-changes/
+repoVisibilityPreview = "application/vnd.github.nebula-preview+json"
+
+DEFAULT_BASE_URL = "https://api.github.com"
+DEFAULT_OAUTH_URL = "https://github.com/login/oauth"
+DEFAULT_STATUS_URL = "https://status.github.com"
+DEFAULT_USER_AGENT = "PyGithub/Python"
+# As of 2018-05-17, Github imposes a 10s limit for completion of API requests.
+# Thus, the timeout should be slightly > 10s to account for network/front-end
+# latency.
+DEFAULT_TIMEOUT = 15
+DEFAULT_PER_PAGE = 30
+
+# JWT expiry in seconds. Could be set for max 600 seconds (10 minutes).
+# https://docs.github.com/en/developers/apps/building-github-apps/authenticating-with-github-apps#authenticating-as-a-github-app
+DEFAULT_JWT_EXPIRY = 300
+MIN_JWT_EXPIRY = 15
+MAX_JWT_EXPIRY = 600
+# https://docs.github.com/en/developers/apps/building-github-apps/authenticating-with-github-apps#generating-a-json-web-token-jwt
+# "The time the JWT was created. To protect against clock drift, we recommend you set this 60 seconds in the past."
+DEFAULT_JWT_ISSUED_AT = -60
+# https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-json-web-token-jwt-for-a-github-app
+# "Your JWT must be signed using the RS256 algorithm"
+DEFAULT_JWT_ALGORITHM = "RS256"
+
+# https://docs.github.com/en/rest/guides/best-practices-for-integrators?apiVersion=2022-11-28#dealing-with-secondary-rate-limits
+DEFAULT_SECONDS_BETWEEN_REQUESTS = 0.25
+DEFAULT_SECONDS_BETWEEN_WRITES = 1.0

venv/lib/python3.10/site-packages/github/ContentFile.py

@@ -0,0 +1,280 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Thialfihar <thi@thialfihar.org>                               #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 h.shi <10385628+AnYeMoWang@users.noreply.github.com>          #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Adam Baratz <adam.baratz@gmail.com>                           #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Alice GIRARD <bouhahah@gmail.com>                             #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+import base64
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import github.GitCommit
+import github.GithubObject
+import github.License
+import github.Repository
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet, _ValuedAttribute
+
+if TYPE_CHECKING:
+    from github.GitCommit import GitCommit
+    from github.License import License
+    from github.Repository import Repository
+
+
+class ContentFile(CompletableGithubObject):
+    """
+    This class represents ContentFiles.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/repos#contents
+
+    The OpenAPI schema can be found at
+    - /components/schemas/code-search-result-item
+    - /components/schemas/content-directory
+    - /components/schemas/content-file
+    - /components/schemas/content-submodule
+    - /components/schemas/content-symlink
+    - /components/schemas/file-commit
+    - /components/schemas/license-content
+
+    """
+
+    def _initAttributes(self) -> None:
+        self.__links: Attribute[dict[str, Any]] = NotSet
+        self._commit: Attribute[GitCommit] = NotSet
+        self._content: Attribute[str] = NotSet
+        self._download_url: Attribute[str] = NotSet
+        self._encoding: Attribute[str] = NotSet
+        self._file_size: Attribute[int] = NotSet
+        self._git_url: Attribute[str] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._language: Attribute[str] = NotSet
+        self._last_modified_at: Attribute[datetime] = NotSet
+        self._license: Attribute[License] = NotSet
+        self._line_numbers: Attribute[list[str]] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._path: Attribute[str] = NotSet
+        self._repository: Attribute[Repository] = NotSet
+        self._score: Attribute[float] = NotSet
+        self._sha: Attribute[str] = NotSet
+        self._size: Attribute[int] = NotSet
+        self._submodule_git_url: Attribute[str] = NotSet
+        self._target: Attribute[str] = NotSet
+        self._text_matches: Attribute[str] = NotSet
+        self._type: Attribute[str] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"path": self._path.value})
+
+    @property
+    def _links(self) -> dict[str, Any]:
+        self._completeIfNotSet(self.__links)
+        return self.__links.value
+
+    @property
+    def commit(self) -> GitCommit:
+        self._completeIfNotSet(self._commit)
+        return self._commit.value
+
+    @property
+    def content(self) -> str:
+        self._completeIfNotSet(self._content)
+        return self._content.value
+
+    @property
+    def decoded_content(self) -> bytes:
+        assert self.encoding == "base64", f"unsupported encoding: {self.encoding}"
+        return base64.b64decode(bytearray(self.content, "utf-8"))
+
+    @property
+    def download_url(self) -> str:
+        self._completeIfNotSet(self._download_url)
+        return self._download_url.value
+
+    @property
+    def encoding(self) -> str:
+        self._completeIfNotSet(self._encoding)
+        return self._encoding.value
+
+    @property
+    def file_size(self) -> int:
+        self._completeIfNotSet(self._file_size)
+        return self._file_size.value
+
+    @property
+    def git_url(self) -> str:
+        self._completeIfNotSet(self._git_url)
+        return self._git_url.value
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def language(self) -> str:
+        self._completeIfNotSet(self._language)
+        return self._language.value
+
+    @property
+    def last_modified_at(self) -> datetime:
+        self._completeIfNotSet(self._last_modified_at)
+        return self._last_modified_at.value
+
+    @property
+    def license(self) -> License:
+        self._completeIfNotSet(self._license)
+        return self._license.value
+
+    @property
+    def line_numbers(self) -> list[str]:
+        self._completeIfNotSet(self._line_numbers)
+        return self._line_numbers.value
+
+    @property
+    def name(self) -> str:
+        self._completeIfNotSet(self._name)
+        return self._name.value
+
+    @property
+    def path(self) -> str:
+        self._completeIfNotSet(self._path)
+        return self._path.value
+
+    @property
+    def repository(self) -> Repository:
+        if self._repository is NotSet:
+            # The repository was not set automatically, so it must be looked up by url.
+            repo_url = "/".join(self.url.split("/")[:6])  # pragma no cover (Should be covered)
+            self._repository = _ValuedAttribute(
+                github.Repository.Repository(self._requester, self._headers, {"url": repo_url}, completed=False)
+            )  # pragma no cover (Should be covered)
+        return self._repository.value
+
+    @property
+    def score(self) -> float:
+        self._completeIfNotSet(self._score)
+        return self._score.value
+
+    @property
+    def sha(self) -> str:
+        self._completeIfNotSet(self._sha)
+        return self._sha.value
+
+    @property
+    def size(self) -> int:
+        self._completeIfNotSet(self._size)
+        return self._size.value
+
+    @property
+    def submodule_git_url(self) -> str:
+        self._completeIfNotSet(self._submodule_git_url)
+        return self._submodule_git_url.value
+
+    @property
+    def target(self) -> str:
+        self._completeIfNotSet(self._target)
+        return self._target.value
+
+    @property
+    def text_matches(self) -> str:
+        self._completeIfNotSet(self._text_matches)
+        return self._text_matches.value
+
+    @property
+    def type(self) -> str:
+        self._completeIfNotSet(self._type)
+        return self._type.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "_links" in attributes:  # pragma no branch
+            self.__links = self._makeDictAttribute(attributes["_links"])
+        if "commit" in attributes:  # pragma no branch
+            self._commit = self._makeClassAttribute(github.GitCommit.GitCommit, attributes["commit"])
+        if "content" in attributes:  # pragma no branch
+            self._content = self._makeStringAttribute(attributes["content"])
+        if "download_url" in attributes:  # pragma no branch
+            self._download_url = self._makeStringAttribute(attributes["download_url"])
+        if "encoding" in attributes:  # pragma no branch
+            self._encoding = self._makeStringAttribute(attributes["encoding"])
+        if "file_size" in attributes:  # pragma no branch
+            self._file_size = self._makeIntAttribute(attributes["file_size"])
+        if "git_url" in attributes:  # pragma no branch
+            self._git_url = self._makeStringAttribute(attributes["git_url"])
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "language" in attributes:  # pragma no branch
+            self._language = self._makeStringAttribute(attributes["language"])
+        if "last_modified_at" in attributes:  # pragma no branch
+            self._last_modified_at = self._makeDatetimeAttribute(attributes["last_modified_at"])
+        if "license" in attributes:  # pragma no branch
+            self._license = self._makeClassAttribute(github.License.License, attributes["license"])
+        if "line_numbers" in attributes:  # pragma no branch
+            self._line_numbers = self._makeListOfStringsAttribute(attributes["line_numbers"])
+        if "name" in attributes:  # pragma no branch
+            self._name = self._makeStringAttribute(attributes["name"])
+        if "path" in attributes:  # pragma no branch
+            self._path = self._makeStringAttribute(attributes["path"])
+        if "repository" in attributes:  # pragma no branch
+            self._repository = self._makeClassAttribute(github.Repository.Repository, attributes["repository"])
+        if "score" in attributes:  # pragma no branch
+            self._score = self._makeFloatAttribute(attributes["score"])
+        if "sha" in attributes:  # pragma no branch
+            self._sha = self._makeStringAttribute(attributes["sha"])
+        if "size" in attributes:  # pragma no branch
+            self._size = self._makeIntAttribute(attributes["size"])
+        if "submodule_git_url" in attributes:  # pragma no branch
+            self._submodule_git_url = self._makeStringAttribute(attributes["submodule_git_url"])
+        if "target" in attributes:  # pragma no branch
+            self._target = self._makeStringAttribute(attributes["target"])
+        if "text_matches" in attributes:  # pragma no branch
+            self._text_matches = self._makeListOfDictsAttribute(attributes["text_matches"])
+        if "type" in attributes:  # pragma no branch
+            self._type = self._makeStringAttribute(attributes["type"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/Copilot.py

@@ -0,0 +1,96 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2024 Pasha Fateev <pasha@autokitteh.com>                           #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import github.CopilotSeat
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+from github.PaginatedList import PaginatedList
+
+if TYPE_CHECKING:
+    from github.CopilotSeat import CopilotSeat
+    from github.Requester import Requester
+
+
+class Copilot(NonCompletableGithubObject):
+    def __init__(self, requester: Requester, org_name: str) -> None:
+        super().__init__(requester, {}, {"org_name": org_name})
+
+    def _initAttributes(self) -> None:
+        self._org_name: Attribute[str] = NotSet
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "org_name" in attributes:  # pragma no branch
+            self._org_name = self._makeStringAttribute(attributes["org_name"])
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"org_name": self._org_name.value if self._org_name is not NotSet else NotSet})
+
+    @property
+    def org_name(self) -> str:
+        return self._org_name.value
+
+    def get_seats(self) -> PaginatedList[CopilotSeat]:
+        """
+        :calls: `GET /orgs/{org}/copilot/billing/seats <https://docs.github.com/en/rest/copilot/copilot-business>`_
+        """
+        url = f"/orgs/{self._org_name.value}/copilot/billing/seats"
+        return PaginatedList(
+            github.CopilotSeat.CopilotSeat,
+            self._requester,
+            url,
+            None,
+            list_item="seats",
+        )
+
+    def add_seats(self, selected_usernames: list[str]) -> int:
+        """
+        :calls: `POST /orgs/{org}/copilot/billing/selected_users <https://docs.github.com/en/rest/copilot/copilot-business>`_
+        :param selected_usernames: List of usernames to add Copilot seats for
+        :rtype: int
+        :return: Number of seats created
+        """
+        url = f"/orgs/{self._org_name.value}/copilot/billing/selected_users"
+        _, data = self._requester.requestJsonAndCheck(
+            "POST",
+            url,
+            input={"selected_usernames": selected_usernames},
+        )
+        return data["seats_created"]
+
+    def remove_seats(self, selected_usernames: list[str]) -> int:
+        """
+        :calls: `DELETE /orgs/{org}/copilot/billing/selected_users <https://docs.github.com/en/rest/copilot/copilot-business>`_
+        :param selected_usernames: List of usernames to remove Copilot seats for
+        :rtype: int
+        :return: Number of seats cancelled
+        """
+        url = f"/orgs/{self._org_name.value}/copilot/billing/selected_users"
+        _, data = self._requester.requestJsonAndCheck(
+            "DELETE",
+            url,
+            input={"selected_usernames": selected_usernames},
+        )
+        return data["seats_cancelled"]

venv/lib/python3.10/site-packages/github/CopilotSeat.py

@@ -0,0 +1,96 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2024 Pasha Fateev <pasha@autokitteh.com>                           #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import github.NamedUser
+import github.Team
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet, _NotSetType
+
+
+class CopilotSeat(NonCompletableGithubObject):
+    def _initAttributes(self) -> None:
+        self._created_at: Attribute[datetime] | _NotSetType = NotSet
+        self._updated_at: Attribute[datetime] | _NotSetType = NotSet
+        self._pending_cancellation_date: Attribute[datetime] | _NotSetType = NotSet
+        self._last_activity_at: Attribute[datetime] | _NotSetType = NotSet
+        self._last_activity_editor: Attribute[str] | _NotSetType = NotSet
+        self._plan_type: Attribute[str] | _NotSetType = NotSet
+        self._assignee: Attribute[github.NamedUser.NamedUser] | _NotSetType = NotSet
+        self._assigning_team: Attribute[github.Team.Team] | _NotSetType = NotSet
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "created_at" in attributes:
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "updated_at" in attributes:
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "pending_cancellation_date" in attributes:
+            self._pending_cancellation_date = self._makeDatetimeAttribute(attributes["pending_cancellation_date"])
+        if "last_activity_at" in attributes:
+            self._last_activity_at = self._makeDatetimeAttribute(attributes["last_activity_at"])
+        if "last_activity_editor" in attributes:
+            self._last_activity_editor = self._makeStringAttribute(attributes["last_activity_editor"])
+        if "plan_type" in attributes:
+            self._plan_type = self._makeStringAttribute(attributes["plan_type"])
+        if "assignee" in attributes:
+            self._assignee = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["assignee"])
+        if "assigning_team" in attributes:
+            self._assigning_team = self._makeClassAttribute(github.Team.Team, attributes["assigning_team"])
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"assignee": self._assignee.value})
+
+    @property
+    def created_at(self) -> datetime:
+        return self._created_at.value
+
+    @property
+    def updated_at(self) -> datetime:
+        return self._updated_at.value
+
+    @property
+    def pending_cancellation_date(self) -> datetime:
+        return self._pending_cancellation_date.value
+
+    @property
+    def last_activity_at(self) -> datetime:
+        return self._last_activity_at.value
+
+    @property
+    def last_activity_editor(self) -> str:
+        return self._last_activity_editor.value
+
+    @property
+    def plan_type(self) -> str:
+        return self._plan_type.value
+
+    @property
+    def assignee(self) -> github.NamedUser.NamedUser:
+        return self._assignee.value
+
+    @property
+    def assigning_team(self) -> github.Team.Team:
+        return self._assigning_team.value

venv/lib/python3.10/site-packages/github/DefaultCodeSecurityConfig.py

@@ -0,0 +1,84 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Justin Kufro <jkufro@andrew.cmu.edu>                          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Bill Napier <napier@pobox.com>                                #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import Any
+
+import github.CodeSecurityConfig
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class DefaultCodeSecurityConfig(NonCompletableGithubObject):
+    """
+    This class represents a Default Configurations for Code Security.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/code-security/configurations.
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._configuration: Attribute[github.CodeSecurityConfig.CodeSecurityConfig] = NotSet
+        self._default_for_new_repos: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__(
+            {
+                "default_for_new_repos": self.default_for_new_repos,
+            }
+        )
+
+    @property
+    def configuration(self) -> github.CodeSecurityConfig.CodeSecurityConfig:
+        return self._configuration.value
+
+    @property
+    def default_for_new_repos(self) -> str:
+        return self._default_for_new_repos.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "configuration" in attributes:  # pragma no branch
+            self._configuration = self._makeClassAttribute(
+                github.CodeSecurityConfig.CodeSecurityConfig, attributes["configuration"]
+            )
+        if "default_for_new_repos" in attributes:  # pragma no branch
+            self._default_for_new_repos = self._makeStringAttribute(attributes["default_for_new_repos"])

venv/lib/python3.10/site-packages/github/DependabotAlert.py

@@ -0,0 +1,173 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2024 Thomas Cooper <coopernetes@proton.me>                         #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import github.AdvisoryVulnerabilityPackage
+import github.DependabotAlertAdvisory
+import github.DependabotAlertDependency
+import github.DependabotAlertVulnerability
+import github.NamedUser
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+if TYPE_CHECKING:
+    from github.DependabotAlertAdvisory import DependabotAlertAdvisory
+    from github.DependabotAlertDependency import DependabotAlertDependency
+    from github.DependabotAlertVulnerability import DependabotAlertVulnerability
+    from github.NamedUser import NamedUser
+
+
+class DependabotAlert(NonCompletableGithubObject):
+    """
+    This class represents a DependabotAlert.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/dependabot/alerts
+
+    The OpenAPI schema can be found at
+    - /components/schemas/dependabot-alert
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._auto_dismissed_at: Attribute[datetime] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._dependency: Attribute[DependabotAlertDependency] = NotSet
+        self._dismissed_at: Attribute[datetime | None] = NotSet
+        self._dismissed_by: Attribute[NamedUser | None] = NotSet
+        self._dismissed_comment: Attribute[str | None] = NotSet
+        self._dismissed_reason: Attribute[str | None] = NotSet
+        self._fixed_at: Attribute[str] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._number: Attribute[int] = NotSet
+        self._security_advisory: Attribute[DependabotAlertAdvisory] = NotSet
+        self._security_vulnerability: Attribute[DependabotAlertVulnerability] = NotSet
+        self._state: Attribute[str] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"number": self.number, "ghsa_id": self.security_advisory.ghsa_id})
+
+    @property
+    def auto_dismissed_at(self) -> datetime:
+        return self._auto_dismissed_at.value
+
+    @property
+    def created_at(self) -> datetime:
+        return self._created_at.value
+
+    @property
+    def dependency(self) -> DependabotAlertDependency:
+        return self._dependency.value
+
+    @property
+    def dismissed_at(self) -> datetime | None:
+        return self._dismissed_at.value
+
+    @property
+    def dismissed_by(self) -> NamedUser | None:
+        return self._dismissed_by.value
+
+    @property
+    def dismissed_comment(self) -> str | None:
+        return self._dismissed_comment.value
+
+    @property
+    def dismissed_reason(self) -> str | None:
+        return self._dismissed_reason.value
+
+    @property
+    def fixed_at(self) -> str | None:
+        return self._fixed_at.value
+
+    @property
+    def html_url(self) -> str:
+        return self._html_url.value
+
+    @property
+    def number(self) -> int:
+        return self._number.value
+
+    @property
+    def security_advisory(self) -> DependabotAlertAdvisory:
+        return self._security_advisory.value
+
+    @property
+    def security_vulnerability(self) -> DependabotAlertVulnerability:
+        return self._security_vulnerability.value
+
+    @property
+    def state(self) -> str:
+        return self._state.value
+
+    @property
+    def updated_at(self) -> datetime:
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "auto_dismissed_at" in attributes:  # pragma no branch
+            self._auto_dismissed_at = self._makeDatetimeAttribute(attributes["auto_dismissed_at"])
+        if "created_at" in attributes:
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "dependency" in attributes:
+            self._dependency = self._makeClassAttribute(
+                github.DependabotAlertDependency.DependabotAlertDependency, attributes["dependency"]
+            )
+        if "dismissed_at" in attributes:
+            self._dismissed_at = self._makeDatetimeAttribute(attributes["dismissed_at"])
+        if "dismissed_by" in attributes:
+            self._dismissed_by = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["dismissed_by"])
+        if "dismissed_comment" in attributes:
+            self._dismissed_comment = self._makeStringAttribute(attributes["dismissed_comment"])
+        if "dismissed_reason" in attributes:
+            self._dismissed_reason = self._makeStringAttribute(attributes["dismissed_reason"])
+        if "fixed_at" in attributes:
+            self._fixed_at = self._makeStringAttribute(attributes["fixed_at"])
+        if "html_url" in attributes:
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "number" in attributes:
+            self._number = self._makeIntAttribute(attributes["number"])
+        if "security_advisory" in attributes:
+            self._security_advisory = self._makeClassAttribute(
+                github.DependabotAlertAdvisory.DependabotAlertAdvisory, attributes["security_advisory"]
+            )
+        if "security_vulnerability" in attributes:
+            self._security_vulnerability = self._makeClassAttribute(
+                github.DependabotAlertVulnerability.DependabotAlertVulnerability, attributes["security_vulnerability"]
+            )
+        if "state" in attributes:
+            self._state = self._makeStringAttribute(attributes["state"])
+        if "updated_at" in attributes:
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/DependabotAlertAdvisory.py

@@ -0,0 +1,73 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2024 Thomas Cooper <coopernetes@proton.me>                         #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import github.DependabotAlertVulnerability
+from github.AdvisoryBase import AdvisoryBase
+from github.GithubObject import Attribute, NotSet
+
+if TYPE_CHECKING:
+    from github.DependabotAlertVulnerability import DependabotAlertVulnerability
+
+
+class DependabotAlertAdvisory(AdvisoryBase):
+    """
+    This class represents a package flagged by a Dependabot alert that is vulnerable to a parent SecurityAdvisory.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/dependabot/alerts
+
+    The OpenAPI schema can be found at
+    - /components/schemas/dependabot-alert-security-advisory
+
+    """
+
+    def _initAttributes(self) -> None:
+        super()._initAttributes()
+        self._references: Attribute[list[dict]] = NotSet
+        self._vulnerabilities: Attribute[list[DependabotAlertVulnerability]] = NotSet
+
+    @property
+    def references(self) -> list[dict]:
+        return self._references.value
+
+    @property
+    def vulnerabilities(self) -> list[DependabotAlertVulnerability]:
+        return self._vulnerabilities.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "references" in attributes:
+            self._references = self._makeListOfDictsAttribute(
+                attributes["references"],
+            )
+        if "vulnerabilities" in attributes:
+            self._vulnerabilities = self._makeListOfClassesAttribute(
+                github.DependabotAlertVulnerability.DependabotAlertVulnerability,
+                attributes["vulnerabilities"],
+            )
+        super()._useAttributes(attributes)

venv/lib/python3.10/site-packages/github/DependabotAlertDependency.py

@@ -0,0 +1,80 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2024 Thomas Cooper <coopernetes@proton.me>                         #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import Any
+
+from github.AdvisoryVulnerabilityPackage import AdvisoryVulnerabilityPackage
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class DependabotAlertDependency(NonCompletableGithubObject):
+    """
+    This class represents a DependabotAlertDependency.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/dependabot/alerts
+
+    The OpenAPI schema can be found at
+    - /components/schemas/dependabot-alert/properties/dependency
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._manifest_path: Attribute[str] = NotSet
+        self._package: Attribute[AdvisoryVulnerabilityPackage] = NotSet
+        self._scope: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__(
+            {
+                "package": self.package,
+                "manifest_path": self.manifest_path,
+            }
+        )
+
+    @property
+    def manifest_path(self) -> str:
+        return self._manifest_path.value
+
+    @property
+    def package(self) -> AdvisoryVulnerabilityPackage:
+        return self._package.value
+
+    @property
+    def scope(self) -> str:
+        return self._scope.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "manifest_path" in attributes:
+            self._manifest_path = self._makeStringAttribute(attributes["manifest_path"])
+        if "package" in attributes:
+            self._package = self._makeClassAttribute(
+                AdvisoryVulnerabilityPackage,
+                attributes["package"],
+            )
+        if "scope" in attributes:
+            self._scope = self._makeStringAttribute(attributes["scope"])

venv/lib/python3.10/site-packages/github/DependabotAlertVulnerability.py

@@ -0,0 +1,83 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Thomas Cooper <coopernetes@proton.me>                         #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import github.AdvisoryVulnerabilityPackage
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+if TYPE_CHECKING:
+    from github.AdvisoryVulnerabilityPackage import AdvisoryVulnerabilityPackage
+
+
+class DependabotAlertVulnerability(NonCompletableGithubObject):
+    """
+    A vulnerability represented in a Dependabot alert.
+
+    The OpenAPI schema can be found at
+    - /components/schemas/dependabot-alert-security-vulnerability
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._first_patched_version: Attribute[dict] = NotSet
+        self._package: Attribute[AdvisoryVulnerabilityPackage] = NotSet
+        self._severity: Attribute[str] = NotSet
+        self._vulnerable_version_range: Attribute[str | None] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"package": self.package, "severity": self.severity})
+
+    @property
+    def first_patched_version(self) -> dict:
+        return self._first_patched_version.value
+
+    @property
+    def package(self) -> AdvisoryVulnerabilityPackage:
+        return self._package.value
+
+    @property
+    def severity(self) -> str:
+        return self._severity.value
+
+    @property
+    def vulnerable_version_range(self) -> str | None:
+        return self._vulnerable_version_range.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "first_patched_version" in attributes:
+            self._first_patched_version = self._makeDictAttribute(
+                attributes["first_patched_version"],
+            )
+        if "package" in attributes:
+            self._package = self._makeClassAttribute(
+                github.AdvisoryVulnerabilityPackage.AdvisoryVulnerabilityPackage,
+                attributes["package"],
+            )
+        if "severity" in attributes:
+            self._severity = self._makeStringAttribute(attributes["severity"])
+        if "vulnerable_version_range" in attributes:
+            self._vulnerable_version_range = self._makeStringAttribute(attributes["vulnerable_version_range"])

venv/lib/python3.10/site-packages/github/Deployment.py

@@ -0,0 +1,298 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2015 Matt Babineau <mbabineau@dataxu.com>                          #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Martijn Koster <mak-github@greenhills.co.uk>                  #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Colby Gallup <colbygallup@gmail.com>                          #
+# Copyright 2020 Pascal Hofmann <mail@pascalhofmann.de>                        #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Nevins <nevins-b@users.noreply.github.com>                    #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import github.Consts
+import github.DeploymentStatus
+import github.GithubApp
+import github.NamedUser
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet, Opt
+from github.PaginatedList import PaginatedList
+
+if TYPE_CHECKING:
+    from github.GithubApp import GithubApp
+    from github.NamedUser import NamedUser
+
+
+class Deployment(CompletableGithubObject):
+    """
+    This class represents Deployments.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/repos#deployments
+
+    The OpenAPI schema can be found at
+    - /components/schemas/deployment
+    - /components/schemas/deployment-simple
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._created_at: Attribute[datetime] = NotSet
+        self._creator: Attribute[NamedUser] = NotSet
+        self._description: Attribute[str] = NotSet
+        self._environment: Attribute[str] = NotSet
+        self._id: Attribute[int] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._original_environment: Attribute[str] = NotSet
+        self._payload: Attribute[dict[str, Any]] = NotSet
+        self._performed_via_github_app: Attribute[GithubApp] = NotSet
+        self._production_environment: Attribute[bool] = NotSet
+        self._ref: Attribute[str] = NotSet
+        self._repository_url: Attribute[str] = NotSet
+        self._sha: Attribute[str] = NotSet
+        self._statuses_url: Attribute[str] = NotSet
+        self._task: Attribute[str] = NotSet
+        self._transient_environment: Attribute[bool] = NotSet
+        self._updated_at: Attribute[datetime | None] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value, "url": self._url.value})
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def creator(self) -> NamedUser:
+        self._completeIfNotSet(self._creator)
+        return self._creator.value
+
+    @property
+    def description(self) -> str:
+        self._completeIfNotSet(self._description)
+        return self._description.value
+
+    @property
+    def environment(self) -> str:
+        self._completeIfNotSet(self._environment)
+        return self._environment.value
+
+    @property
+    def id(self) -> int:
+        self._completeIfNotSet(self._id)
+        return self._id.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def original_environment(self) -> str:
+        self._completeIfNotSet(self._original_environment)
+        return self._original_environment.value
+
+    @property
+    def payload(self) -> dict[str, Any]:
+        self._completeIfNotSet(self._payload)
+        return self._payload.value
+
+    @property
+    def performed_via_github_app(self) -> GithubApp:
+        self._completeIfNotSet(self._performed_via_github_app)
+        return self._performed_via_github_app.value
+
+    @property
+    def production_environment(self) -> bool:
+        self._completeIfNotSet(self._production_environment)
+        return self._production_environment.value
+
+    @property
+    def ref(self) -> str:
+        self._completeIfNotSet(self._ref)
+        return self._ref.value
+
+    @property
+    def repository_url(self) -> str:
+        self._completeIfNotSet(self._repository_url)
+        return self._repository_url.value
+
+    @property
+    def sha(self) -> str:
+        self._completeIfNotSet(self._sha)
+        return self._sha.value
+
+    @property
+    def statuses_url(self) -> str:
+        self._completeIfNotSet(self._statuses_url)
+        return self._statuses_url.value
+
+    @property
+    def task(self) -> str:
+        self._completeIfNotSet(self._task)
+        return self._task.value
+
+    @property
+    def transient_environment(self) -> bool:
+        self._completeIfNotSet(self._transient_environment)
+        return self._transient_environment.value
+
+    @property
+    def updated_at(self) -> datetime | None:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def get_statuses(self) -> PaginatedList[github.DeploymentStatus.DeploymentStatus]:
+        """
+        :calls: `GET /repos/{owner}/deployments/{deployment_id}/statuses <https://docs.github.com/en/rest/reference/repos#list-deployments>`_
+        """
+        return PaginatedList(
+            github.DeploymentStatus.DeploymentStatus,
+            self._requester,
+            f"{self.url}/statuses",
+            None,
+            headers={"Accept": self._get_accept_header()},
+        )
+
+    def get_status(self, id_: int) -> github.DeploymentStatus.DeploymentStatus:
+        """
+        :calls: `GET /repos/{owner}/deployments/{deployment_id}/statuses/{status_id}  <https://docs.github.com/en/rest/reference/repos#get-a-deployment>`_
+        """
+        assert isinstance(id_, int), id_
+        headers, data = self._requester.requestJsonAndCheck(
+            "GET",
+            f"{self.url}/statuses/{id_}",
+            headers={"Accept": self._get_accept_header()},
+        )
+        return github.DeploymentStatus.DeploymentStatus(self._requester, headers, data, completed=True)
+
+    def create_status(
+        self,
+        state: str,
+        target_url: Opt[str] = NotSet,
+        description: Opt[str] = NotSet,
+        environment: Opt[str] = NotSet,
+        environment_url: Opt[str] = NotSet,
+        auto_inactive: Opt[bool] = NotSet,
+    ) -> github.DeploymentStatus.DeploymentStatus:
+        """
+        :calls: `POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses <https://docs.github.com/en/rest/reference/repos#create-a-deployment-status>`_
+        """
+        assert isinstance(state, str), state
+        assert target_url is NotSet or isinstance(target_url, str), target_url
+        assert description is NotSet or isinstance(description, str), description
+        assert environment is NotSet or isinstance(environment, str), environment
+        assert environment_url is NotSet or isinstance(environment_url, str), environment_url
+        assert auto_inactive is NotSet or isinstance(auto_inactive, bool), auto_inactive
+
+        post_parameters = NotSet.remove_unset_items(
+            {
+                "state": state,
+                "target_url": target_url,
+                "description": description,
+                "environment": environment,
+                "environment_url": environment_url,
+                "auto_inactive": auto_inactive,
+            }
+        )
+
+        headers, data = self._requester.requestJsonAndCheck(
+            "POST",
+            f"{self.url}/statuses",
+            input=post_parameters,
+            headers={"Accept": self._get_accept_header()},
+        )
+        return github.DeploymentStatus.DeploymentStatus(self._requester, headers, data, completed=True)
+
+    @staticmethod
+    def _get_accept_header() -> str:
+        return ", ".join(
+            [
+                github.Consts.deploymentEnhancementsPreview,
+                github.Consts.deploymentStatusEnhancementsPreview,
+            ]
+        )
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "creator" in attributes:  # pragma no branch
+            self._creator = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["creator"])
+        if "description" in attributes:  # pragma no branch
+            self._description = self._makeStringAttribute(attributes["description"])
+        if "environment" in attributes:  # pragma no branch
+            self._environment = self._makeStringAttribute(attributes["environment"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "original_environment" in attributes:  # pragma no branch
+            self._original_environment = self._makeStringAttribute(attributes["original_environment"])
+        if "payload" in attributes:  # pragma no branch
+            self._payload = self._makeDictAttribute(attributes["payload"])
+        if "performed_via_github_app" in attributes:  # pragma no branch
+            self._performed_via_github_app = self._makeClassAttribute(
+                github.GithubApp.GithubApp, attributes["performed_via_github_app"]
+            )
+        if "production_environment" in attributes:  # pragma no branch
+            self._production_environment = self._makeBoolAttribute(attributes["production_environment"])
+        if "ref" in attributes:  # pragma no branch
+            self._ref = self._makeStringAttribute(attributes["ref"])
+        if "repository_url" in attributes:  # pragma no branch
+            self._repository_url = self._makeStringAttribute(attributes["repository_url"])
+        if "sha" in attributes:  # pragma no branch
+            self._sha = self._makeStringAttribute(attributes["sha"])
+        if "statuses_url" in attributes:  # pragma no branch
+            self._statuses_url = self._makeStringAttribute(attributes["statuses_url"])
+        if "task" in attributes:  # pragma no branch
+            self._task = self._makeStringAttribute(attributes["task"])
+        if "transient_environment" in attributes:  # pragma no branch
+            self._transient_environment = self._makeBoolAttribute(attributes["transient_environment"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/DeploymentStatus.py

@@ -0,0 +1,198 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2015 Matt Babineau <mbabineau@dataxu.com>                          #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Martijn Koster <mak-github@greenhills.co.uk>                  #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Colby Gallup <colbygallup@gmail.com>                          #
+# Copyright 2020 Pascal Hofmann <mail@pascalhofmann.de>                        #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import github.GithubApp
+import github.NamedUser
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+
+if TYPE_CHECKING:
+    from github.GithubApp import GithubApp
+    from github.NamedUser import NamedUser
+
+
+class DeploymentStatus(CompletableGithubObject):
+    """
+    This class represents Deployment Statuses.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/repos#deployments
+
+    The OpenAPI schema can be found at
+    - /components/schemas/deployment-status
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._created_at: Attribute[datetime] = NotSet
+        self._creator: Attribute[NamedUser] = NotSet
+        self._deployment_url: Attribute[str] = NotSet
+        self._description: Attribute[str] = NotSet
+        self._environment: Attribute[str] = NotSet
+        self._environment_url: Attribute[str] = NotSet
+        self._id: Attribute[int] = NotSet
+        self._log_url: Attribute[str] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._performed_via_github_app: Attribute[GithubApp] = NotSet
+        self._repository_url: Attribute[str] = NotSet
+        self._state: Attribute[str] = NotSet
+        self._target_url: Attribute[str] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value, "url": self._url.value})
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def creator(self) -> NamedUser:
+        self._completeIfNotSet(self._creator)
+        return self._creator.value
+
+    @property
+    def deployment_url(self) -> str:
+        self._completeIfNotSet(self._deployment_url)
+        return self._deployment_url.value
+
+    @property
+    def description(self) -> str:
+        self._completeIfNotSet(self._description)
+        return self._description.value
+
+    @property
+    def environment(self) -> str:
+        self._completeIfNotSet(self._environment)
+        return self._environment.value
+
+    @property
+    def environment_url(self) -> str:
+        self._completeIfNotSet(self._environment_url)
+        return self._environment_url.value
+
+    @property
+    def id(self) -> int:
+        self._completeIfNotSet(self._id)
+        return self._id.value
+
+    @property
+    def log_url(self) -> str:
+        self._completeIfNotSet(self._log_url)
+        return self._log_url.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def performed_via_github_app(self) -> GithubApp:
+        self._completeIfNotSet(self._performed_via_github_app)
+        return self._performed_via_github_app.value
+
+    @property
+    def repository_url(self) -> str:
+        self._completeIfNotSet(self._repository_url)
+        return self._repository_url.value
+
+    @property
+    def state(self) -> str:
+        self._completeIfNotSet(self._state)
+        return self._state.value
+
+    @property
+    def target_url(self) -> str:
+        self._completeIfNotSet(self._target_url)
+        return self._target_url.value
+
+    @property
+    def updated_at(self) -> datetime:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "creator" in attributes:  # pragma no branch
+            self._creator = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["creator"])
+        if "deployment_url" in attributes:  # pragma no branch
+            self._deployment_url = self._makeStringAttribute(attributes["deployment_url"])
+        if "description" in attributes:  # pragma no branch
+            self._description = self._makeStringAttribute(attributes["description"])
+        if "environment" in attributes:  # pragma no branch
+            self._environment = self._makeStringAttribute(attributes["environment"])
+        if "environment_url" in attributes:  # pragma no branch
+            self._environment_url = self._makeStringAttribute(attributes["environment_url"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "log_url" in attributes:  # pragma no branch
+            self._log_url = self._makeStringAttribute(attributes["log_url"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "performed_via_github_app" in attributes:  # pragma no branch
+            self._performed_via_github_app = self._makeClassAttribute(
+                github.GithubApp.GithubApp, attributes["performed_via_github_app"]
+            )
+        if "repository_url" in attributes:  # pragma no branch
+            self._repository_url = self._makeStringAttribute(attributes["repository_url"])
+        if "state" in attributes:  # pragma no branch
+            self._state = self._makeStringAttribute(attributes["state"])
+        if "target_url" in attributes:  # pragma no branch
+            self._target_url = self._makeStringAttribute(attributes["target_url"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/DiscussionBase.py

@@ -0,0 +1,135 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Mark Walker <mark.walker@realbuzz.com>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import github.GithubObject
+import github.NamedUser
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+
+
+class DiscussionBase(CompletableGithubObject):
+    """
+    This class represents a the shared attributes between RepositoryDiscussion and TeamDiscussion
+    https://docs.github.com/en/graphql/reference/objects#discussion
+    https://docs.github.com/en/rest/reference/teams#discussions
+    """
+
+    def _initAttributes(self) -> None:
+        self._author: Attribute[github.NamedUser.NamedUser | None] = NotSet
+        self._body: Attribute[str] = NotSet
+        self._body_html: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._last_edited_at: Attribute[datetime] = NotSet
+        self._number: Attribute[int] = NotSet
+        self._title: Attribute[str] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"number": self._number.value, "title": self._title.value})
+
+    @property
+    def author(self) -> github.NamedUser.NamedUser | None:
+        self._completeIfNotSet(self._author)
+        return self._author.value
+
+    @property
+    def body(self) -> str:
+        self._completeIfNotSet(self._body)
+        return self._body.value
+
+    @property
+    def body_html(self) -> str:
+        self._completeIfNotSet(self._body_html)
+        return self._body_html.value
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def last_edited_at(self) -> datetime:
+        self._completeIfNotSet(self._last_edited_at)
+        return self._last_edited_at.value
+
+    @property
+    def number(self) -> int:
+        self._completeIfNotSet(self._number)
+        return self._number.value
+
+    @property
+    def title(self) -> str:
+        self._completeIfNotSet(self._title)
+        return self._title.value
+
+    @property
+    def updated_at(self) -> datetime:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "author" in attributes:  # pragma no branch
+            self._author = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["author"])
+        if "body" in attributes:  # pragma no branch
+            self._body = self._makeStringAttribute(attributes["body"])
+        if "body_html" in attributes:  # pragma no branch
+            self._body_html = self._makeStringAttribute(attributes["body_html"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "last_edited_at" in attributes:  # pragma no branch
+            self._last_edited_at = self._makeDatetimeAttribute(attributes["last_edited_at"])
+        if "number" in attributes:  # pragma no branch
+            self._number = self._makeIntAttribute(attributes["number"])
+        if "title" in attributes:
+            self._title = self._makeStringAttribute(attributes["title"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/DiscussionCommentBase.py

@@ -0,0 +1,135 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Mark Walker <mark.walker@realbuzz.com>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import github.GithubObject
+import github.NamedUser
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+
+
+class DiscussionCommentBase(CompletableGithubObject):
+    """
+    This class represents a the shared attributes between RepositoryDiscussionComment and TeamDiscussionComment
+    https://docs.github.com/en/graphql/reference/objects#discussioncomment
+    https://docs.github.com/de/rest/teams/discussion-comments
+    """
+
+    def _initAttributes(self) -> None:
+        self._author: Attribute[github.NamedUser.NamedUser | None] = NotSet
+        self._body: Attribute[str] = NotSet
+        self._body_html: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._last_edited_at: Attribute[datetime] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"node_id": self._node_id.value})
+
+    @property
+    def author(self) -> github.NamedUser.NamedUser | None:
+        self._completeIfNotSet(self._author)
+        return self._author.value
+
+    @property
+    def body(self) -> str:
+        self._completeIfNotSet(self._body)
+        return self._body.value
+
+    @property
+    def body_html(self) -> str:
+        self._completeIfNotSet(self._body_html)
+        return self._body_html.value
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def last_edited_at(self) -> datetime:
+        self._completeIfNotSet(self._last_edited_at)
+        return self._last_edited_at.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def updated_at(self) -> datetime:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "author" in attributes:  # pragma no branch
+            self._author = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["author"])
+        if "body" in attributes:  # pragma no branch
+            self._body = self._makeStringAttribute(attributes["body"])
+        if "body_html" in attributes:  # pragma no branch
+            self._body_html = self._makeStringAttribute(attributes["body_html"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "last_edited_at" in attributes:  # pragma no branch
+            self._last_edited_at = self._makeDatetimeAttribute(attributes["last_edited_at"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/Download.py

@@ -0,0 +1,249 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+
+
+class Download(CompletableGithubObject):
+    """
+    This class represents Downloads.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/repos
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._accesskeyid: Attribute[str] = NotSet
+        self._acl: Attribute[str] = NotSet
+        self._bucket: Attribute[str] = NotSet
+        self._content_type: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._description: Attribute[str] = NotSet
+        self._download_count: Attribute[int] = NotSet
+        self._expirationdate: Attribute[datetime] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._id: Attribute[int] = NotSet
+        self._mime_type: Attribute[str] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._path: Attribute[str] = NotSet
+        self._policy: Attribute[str] = NotSet
+        self._prefix: Attribute[str] = NotSet
+        self._redirect: Attribute[bool] = NotSet
+        self._s3_url: Attribute[str] = NotSet
+        self._signature: Attribute[str] = NotSet
+        self._size: Attribute[int] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value})
+
+    @property
+    def accesskeyid(self) -> str:
+        self._completeIfNotSet(self._accesskeyid)
+        return self._accesskeyid.value
+
+    @property
+    def acl(self) -> str:
+        self._completeIfNotSet(self._acl)
+        return self._acl.value
+
+    @property
+    def bucket(self) -> str:
+        self._completeIfNotSet(self._bucket)
+        return self._bucket.value
+
+    @property
+    def content_type(self) -> str:
+        self._completeIfNotSet(self._content_type)
+        return self._content_type.value
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def description(self) -> str:
+        self._completeIfNotSet(self._description)
+        return self._description.value
+
+    @property
+    def download_count(self) -> int:
+        self._completeIfNotSet(self._download_count)
+        return self._download_count.value
+
+    @property
+    def expirationdate(self) -> datetime:
+        self._completeIfNotSet(self._expirationdate)
+        return self._expirationdate.value
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def id(self) -> int:
+        self._completeIfNotSet(self._id)
+        return self._id.value
+
+    @property
+    def mime_type(self) -> str:
+        self._completeIfNotSet(self._mime_type)
+        return self._mime_type.value
+
+    @property
+    def name(self) -> str:
+        self._completeIfNotSet(self._name)
+        return self._name.value
+
+    @property
+    def path(self) -> str:
+        self._completeIfNotSet(self._path)
+        return self._path.value
+
+    @property
+    def policy(self) -> str:
+        self._completeIfNotSet(self._policy)
+        return self._policy.value
+
+    @property
+    def prefix(self) -> str:
+        self._completeIfNotSet(self._prefix)
+        return self._prefix.value
+
+    @property
+    def redirect(self) -> bool:
+        self._completeIfNotSet(self._redirect)
+        return self._redirect.value
+
+    @property
+    def s3_url(self) -> str:
+        self._completeIfNotSet(self._s3_url)
+        return self._s3_url.value
+
+    @property
+    def signature(self) -> str:
+        self._completeIfNotSet(self._signature)
+        return self._signature.value
+
+    @property
+    def size(self) -> int:
+        self._completeIfNotSet(self._size)
+        return self._size.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def delete(self) -> None:
+        """
+        :calls: `DELETE /repos/{owner}/{repo}/downloads/{id} <https://docs.github.com/en/rest/reference/repos>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("DELETE", self.url)
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "accesskeyid" in attributes:  # pragma no branch
+            self._accesskeyid = self._makeStringAttribute(
+                attributes["accesskeyid"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "acl" in attributes:  # pragma no branch
+            self._acl = self._makeStringAttribute(
+                attributes["acl"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "bucket" in attributes:  # pragma no branch
+            self._bucket = self._makeStringAttribute(
+                attributes["bucket"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "content_type" in attributes:  # pragma no branch
+            self._content_type = self._makeStringAttribute(attributes["content_type"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "description" in attributes:  # pragma no branch
+            self._description = self._makeStringAttribute(attributes["description"])
+        if "download_count" in attributes:  # pragma no branch
+            self._download_count = self._makeIntAttribute(attributes["download_count"])
+        if "expirationdate" in attributes:  # pragma no branch
+            self._expirationdate = self._makeDatetimeAttribute(
+                attributes["expirationdate"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "mime_type" in attributes:  # pragma no branch
+            self._mime_type = self._makeStringAttribute(
+                attributes["mime_type"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "name" in attributes:  # pragma no branch
+            self._name = self._makeStringAttribute(attributes["name"])
+        if "path" in attributes:  # pragma no branch
+            self._path = self._makeStringAttribute(
+                attributes["path"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "policy" in attributes:  # pragma no branch
+            self._policy = self._makeStringAttribute(
+                attributes["policy"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "prefix" in attributes:  # pragma no branch
+            self._prefix = self._makeStringAttribute(
+                attributes["prefix"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "redirect" in attributes:  # pragma no branch
+            self._redirect = self._makeBoolAttribute(
+                attributes["redirect"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "s3_url" in attributes:  # pragma no branch
+            self._s3_url = self._makeStringAttribute(
+                attributes["s3_url"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "signature" in attributes:  # pragma no branch
+            self._signature = self._makeStringAttribute(
+                attributes["signature"]
+            )  # pragma no cover (was covered only by create_download, which has been removed)
+        if "size" in attributes:  # pragma no branch
+            self._size = self._makeIntAttribute(attributes["size"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/Enterprise.py

@@ -0,0 +1,96 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Mark Amery <markamery@btinternet.com>                         #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2023 YugoHino <henom06@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+import urllib.parse
+from typing import Any, Dict
+
+from github.EnterpriseConsumedLicenses import EnterpriseConsumedLicenses
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+from github.Requester import Requester
+
+
+class Enterprise(NonCompletableGithubObject):
+    """
+    This class represents Enterprises.
+
+    Such objects do not exist in the Github API, so this class merely collects all endpoints the start with
+    /enterprises/{enterprise}/. See methods below for specific endpoints and docs.
+    https://docs.github.com/en/enterprise-cloud@latest/rest/enterprise-admin?apiVersion=2022-11-28
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._enterprise: Attribute[str] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __init__(
+        self,
+        requester: Requester,
+        enterprise: str,
+    ):
+        enterprise = urllib.parse.quote(enterprise)
+        super().__init__(requester, {}, {"enterprise": enterprise, "url": f"/enterprises/{enterprise}"})
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"enterprise": self._enterprise.value})
+
+    @property
+    def enterprise(self) -> str:
+        return self._enterprise.value
+
+    @property
+    def url(self) -> str:
+        return self._url.value
+
+    def get_consumed_licenses(self) -> EnterpriseConsumedLicenses:
+        """
+        :calls: `GET /enterprises/{enterprise}/consumed-licenses <https://docs.github.com/en/enterprise-cloud@latest/rest/enterprise-admin/license#list-enterprise-consumed-licenses>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("GET", self.url + "/consumed-licenses")
+        if "url" not in data:
+            data["url"] = self.url + "/consumed-licenses"
+
+        return EnterpriseConsumedLicenses(self._requester, headers, data, completed=True)
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "enterprise" in attributes:  # pragma no branch
+            self._enterprise = self._makeStringAttribute(attributes["enterprise"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/EnterpriseConsumedLicenses.py

@@ -0,0 +1,109 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2023 YugoHino <henom06@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from typing import Any, Dict
+
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+from github.NamedEnterpriseUser import NamedEnterpriseUser
+from github.PaginatedList import PaginatedList
+
+
+class EnterpriseConsumedLicenses(CompletableGithubObject):
+    """
+    This class represents license consumed by enterprises.
+
+    The reference can be found here
+    https://docs.github.com/en/enterprise-cloud@latest/rest/enterprise-admin/license#list-enterprise-consumed-licenses
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._enterprise: Attribute[str] = NotSet
+        self._total_seats_consumed: Attribute[int] = NotSet
+        self._total_seats_purchased: Attribute[int] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"enterprise": self._enterprise.value})
+
+    @property
+    def enterprise(self) -> str:
+        self._completeIfNotSet(self._enterprise)
+        return self._enterprise.value
+
+    @property
+    def total_seats_consumed(self) -> int:
+        return self._total_seats_consumed.value
+
+    @property
+    def total_seats_purchased(self) -> int:
+        return self._total_seats_purchased.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    def get_users(self) -> PaginatedList[NamedEnterpriseUser]:
+        """
+        :calls: `GET /enterprises/{enterprise}/consumed-licenses <https://docs.github.com/en/enterprise-cloud@latest/rest/enterprise-admin/license#list-enterprise-consumed-licenses>`_
+        """
+
+        url_parameters: Dict[str, Any] = {}
+        return PaginatedList(
+            NamedEnterpriseUser,
+            self._requester,
+            self.url,
+            url_parameters,
+            headers=None,
+            list_item="users",
+            firstData=self.raw_data,
+            firstHeaders=self.raw_headers,
+        )
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "enterprise" in attributes:  # pragma no branch
+            self._enterprise = self._makeStringAttribute(attributes["enterprise"])
+        if "total_seats_consumed" in attributes:  # pragma no branch
+            self._total_seats_consumed = self._makeIntAttribute(attributes["total_seats_consumed"])
+        if "total_seats_purchased" in attributes:  # pragma no branch
+            self._total_seats_purchased = self._makeIntAttribute(attributes["total_seats_purchased"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/Environment.py

@@ -0,0 +1,299 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2017 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2017 Simon <spam@esemi.ru>                                         #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Andrew Dawes <53574062+AndrewJDawes@users.noreply.github.com> #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2023 alson <git@alm.nufan.net>                                     #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import github.EnvironmentDeploymentBranchPolicy
+import github.EnvironmentProtectionRule
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+from github.PaginatedList import PaginatedList
+from github.PublicKey import PublicKey
+from github.Secret import Secret
+from github.Variable import Variable
+
+if TYPE_CHECKING:
+    from github.EnvironmentDeploymentBranchPolicy import EnvironmentDeploymentBranchPolicy
+    from github.EnvironmentProtectionRule import EnvironmentProtectionRule
+
+
+class Environment(CompletableGithubObject):
+    """
+    This class represents Environment.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/deployments#environments
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._created_at: Attribute[datetime] = NotSet
+        self._deployment_branch_policy: Attribute[EnvironmentDeploymentBranchPolicy] = NotSet
+        self._environments_url: Attribute[str] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._id: Attribute[int] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._protection_rules: Attribute[list[EnvironmentProtectionRule]] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"name": self._name.value})
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def deployment_branch_policy(
+        self,
+    ) -> EnvironmentDeploymentBranchPolicy:
+        self._completeIfNotSet(self._deployment_branch_policy)
+        return self._deployment_branch_policy.value
+
+    @property
+    def environments_url(self) -> str:
+        """
+        :type: string
+        """
+        return self._environments_url.value
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def id(self) -> int:
+        self._completeIfNotSet(self._id)
+        return self._id.value
+
+    @property
+    def name(self) -> str:
+        self._completeIfNotSet(self._name)
+        return self._name.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def protection_rules(
+        self,
+    ) -> list[EnvironmentProtectionRule]:
+        self._completeIfNotSet(self._protection_rules)
+        return self._protection_rules.value
+
+    @property
+    def updated_at(self) -> datetime:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        """
+        :type: string
+        """
+        # Construct url from environments_url and name, if self._url. is not set
+        if self._url is NotSet:
+            self._url = self._makeStringAttribute(self.environments_url + "/" + self.name)
+        return self._url.value
+
+    def get_public_key(self) -> PublicKey:
+        """
+        :calls: `GET /repositories/{repository_id}/environments/{environment_name}/secrets/public-key <https://docs.github.com/en/rest/reference#get-a-repository-public-key>`_
+        :rtype: :class:`PublicKey`
+        """
+        # https://stackoverflow.com/a/76474814
+        # https://docs.github.com/en/rest/secrets?apiVersion=2022-11-28#get-an-environment-public-key
+        headers, data = self._requester.requestJsonAndCheck("GET", f"{self.url}/secrets/public-key")
+        return PublicKey(self._requester, headers, data, completed=True)
+
+    def create_secret(self, secret_name: str, unencrypted_value: str) -> Secret:
+        """
+        :calls: `PUT /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name} <https://docs.github.com/en/rest/secrets#get-a-repository-secret>`_
+        """
+        assert isinstance(secret_name, str), secret_name
+        assert isinstance(unencrypted_value, str), unencrypted_value
+        public_key = self.get_public_key()
+        payload = public_key.encrypt(unencrypted_value)
+        put_parameters = {
+            "key_id": public_key.key_id,
+            "encrypted_value": payload,
+        }
+        self._requester.requestJsonAndCheck("PUT", f"{self.url}/secrets/{secret_name}", input=put_parameters)
+        return Secret(
+            requester=self._requester,
+            headers={},
+            attributes={
+                "name": secret_name,
+                "url": f"{self.url}/secrets/{secret_name}",
+            },
+            completed=False,
+        )
+
+    def get_secrets(self) -> PaginatedList[Secret]:
+        """
+        Gets all repository secrets.
+        """
+        return PaginatedList(
+            Secret,
+            self._requester,
+            f"{self.url}/secrets",
+            None,
+            attributesTransformer=PaginatedList.override_attributes({"secrets_url": f"{self.url}/secrets"}),
+            list_item="secrets",
+        )
+
+    def get_secret(self, secret_name: str) -> Secret:
+        """
+        :calls: 'GET /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name} <https://docs.github.com/en/rest/secrets#get-an-organization-secret>`_
+        """
+        assert isinstance(secret_name, str), secret_name
+        return Secret(
+            requester=self._requester,
+            headers={},
+            attributes={"url": f"{self.url}/secrets/{secret_name}"},
+            completed=False,
+        )
+
+    def create_variable(self, variable_name: str, value: str) -> Variable:
+        """
+        :calls: `POST /repositories/{repository_id}/environments/{environment_name}/variables/{variable_name} <https://docs.github.com/en/rest/variables#create-a-repository-variable>`_
+        """
+        assert isinstance(variable_name, str), variable_name
+        assert isinstance(value, str), value
+        post_parameters = {
+            "name": variable_name,
+            "value": value,
+        }
+        self._requester.requestJsonAndCheck("POST", f"{self.url}/variables", input=post_parameters)
+        return Variable(
+            self._requester,
+            headers={},
+            attributes={
+                "name": variable_name,
+                "value": value,
+                "url": f"{self.url}/variables/{variable_name}",
+            },
+            completed=False,
+        )
+
+    def get_variables(self) -> PaginatedList[Variable]:
+        """
+        Gets all repository variables :rtype: :class:`PaginatedList` of :class:`Variable`
+        """
+        return PaginatedList(
+            Variable,
+            self._requester,
+            f"{self.url}/variables",
+            None,
+            attributesTransformer=PaginatedList.override_attributes({"variables_url": f"{self.url}/variables"}),
+            list_item="variables",
+        )
+
+    def get_variable(self, variable_name: str) -> Variable:
+        """
+        :calls: 'GET /orgs/{org}/variables/{variable_name} <https://docs.github.com/en/rest/variables#get-an-organization-variable>`_
+        :param variable_name: string
+        :rtype: Variable
+        """
+        assert isinstance(variable_name, str), variable_name
+        return Variable(
+            requester=self._requester,
+            headers={},
+            attributes={"url": f"{self.url}/variables/{variable_name}"},
+            completed=False,
+        )
+
+    def delete_secret(self, secret_name: str) -> bool:
+        """
+        :calls: `DELETE /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name} <https://docs.github.com/en/rest/reference#delete-a-repository-secret>`_
+        :param secret_name: string
+        :rtype: bool
+        """
+        assert isinstance(secret_name, str), secret_name
+        status, headers, data = self._requester.requestJson("DELETE", f"{self.url}/secrets/{secret_name}")
+        return status == 204
+
+    def delete_variable(self, variable_name: str) -> bool:
+        """
+        :calls: `DELETE /repositories/{repository_id}/environments/{environment_name}/variables/{variable_name} <https://docs.github.com/en/rest/reference#delete-a-repository-variable>`_
+        :param variable_name: string
+        :rtype: bool
+        """
+        assert isinstance(variable_name, str), variable_name
+        status, headers, data = self._requester.requestJson("DELETE", f"{self.url}/variables/{variable_name}")
+        return status == 204
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "deployment_branch_policy" in attributes:  # pragma no branch
+            self._deployment_branch_policy = self._makeClassAttribute(
+                github.EnvironmentDeploymentBranchPolicy.EnvironmentDeploymentBranchPolicy,
+                attributes["deployment_branch_policy"],
+            )
+        if "environments_url" in attributes:
+            self._environments_url = self._makeStringAttribute(attributes["environments_url"])
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "name" in attributes:  # pragma no branch
+            self._name = self._makeStringAttribute(attributes["name"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "protection_rules" in attributes:  # pragma no branch
+            self._protection_rules = self._makeListOfClassesAttribute(
+                github.EnvironmentProtectionRule.EnvironmentProtectionRule,
+                attributes["protection_rules"],
+            )
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])

venv/lib/python3.10/site-packages/github/EnvironmentDeploymentBranchPolicy.py

@@ -0,0 +1,80 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2023 alson <git@alm.nufan.net>                                     #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from typing import Any, Dict
+
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class EnvironmentDeploymentBranchPolicy(NonCompletableGithubObject):
+    """
+    This class represents a deployment branch policy for an environment.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/deployments#environments
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._custom_branch_policies: Attribute[bool] = NotSet
+        self._protected_branches: Attribute[bool] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({})
+
+    @property
+    def custom_branch_policies(self) -> bool:
+        return self._custom_branch_policies.value
+
+    @property
+    def protected_branches(self) -> bool:
+        return self._protected_branches.value
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "custom_branch_policies" in attributes:  # pragma no branch
+            self._custom_branch_policies = self._makeBoolAttribute(attributes["custom_branch_policies"])
+        if "protected_branches" in attributes:  # pragma no branch
+            self._protected_branches = self._makeBoolAttribute(attributes["protected_branches"])
+
+
+class EnvironmentDeploymentBranchPolicyParams:
+    """
+    This class presents the deployment branch policy parameters as can be configured for an Environment.
+    """
+
+    def __init__(self, protected_branches: bool = False, custom_branch_policies: bool = False):
+        assert isinstance(protected_branches, bool)
+        assert isinstance(custom_branch_policies, bool)
+        self.protected_branches = protected_branches
+        self.custom_branch_policies = custom_branch_policies
+
+    def _asdict(self) -> dict:
+        return {
+            "protected_branches": self.protected_branches,
+            "custom_branch_policies": self.custom_branch_policies,
+        }

venv/lib/python3.10/site-packages/github/EnvironmentProtectionRule.py

@@ -0,0 +1,108 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Adam Baratz <adam.baratz@gmail.com>                           #
+# Copyright 2019 Nick Campbell <nicholas.j.campbell@gmail.com>                 #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2022 Marco Köpcke <hello@parakoopa.de>                             #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2023 alson <git@alm.nufan.net>                                     #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import github.EnvironmentProtectionRuleReviewer
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+if TYPE_CHECKING:
+    from github.EnvironmentProtectionRuleReviewer import EnvironmentProtectionRuleReviewer
+
+
+class EnvironmentProtectionRule(NonCompletableGithubObject):
+    """
+    This class represents a protection rule for an environment.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/deployments#environments
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._id: Attribute[int] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._reviewers: Attribute[list[EnvironmentProtectionRuleReviewer]] = NotSet
+        self._type: Attribute[str] = NotSet
+        self._wait_timer: Attribute[int] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value})
+
+    @property
+    def id(self) -> int:
+        return self._id.value
+
+    @property
+    def node_id(self) -> str:
+        return self._node_id.value
+
+    @property
+    def reviewers(
+        self,
+    ) -> list[EnvironmentProtectionRuleReviewer]:
+        return self._reviewers.value
+
+    @property
+    def type(self) -> str:
+        return self._type.value
+
+    @property
+    def wait_timer(self) -> int:
+        return self._wait_timer.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "reviewers" in attributes:  # pragma no branch
+            self._reviewers = self._makeListOfClassesAttribute(
+                github.EnvironmentProtectionRuleReviewer.EnvironmentProtectionRuleReviewer,
+                attributes["reviewers"],
+            )
+        if "type" in attributes:  # pragma no branch
+            self._type = self._makeStringAttribute(attributes["type"])
+        if "wait_timer" in attributes:  # pragma no branch
+            self._wait_timer = self._makeIntAttribute(attributes["wait_timer"])

venv/lib/python3.10/site-packages/github/EnvironmentProtectionRuleReviewer.py

@@ -0,0 +1,101 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Adam Baratz <adam.baratz@gmail.com>                           #
+# Copyright 2019 Nick Campbell <nicholas.j.campbell@gmail.com>                 #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2023 alson <git@alm.nufan.net>                                     #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from typing import Any
+
+import github.NamedUser
+import github.Team
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class EnvironmentProtectionRuleReviewer(NonCompletableGithubObject):
+    """
+    This class represents a reviewer for an EnvironmentProtectionRule.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/deployments#environments
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._reviewer: Attribute[github.NamedUser.NamedUser | github.Team.Team] = NotSet
+        self._type: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"type": self._type.value})
+
+    @property
+    def reviewer(self) -> github.NamedUser.NamedUser | github.Team.Team:
+        return self._reviewer.value
+
+    @property
+    def type(self) -> str:
+        return self._type.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "reviewer" in attributes and "type" in attributes:  # pragma no branch
+            assert attributes["type"] in ("User", "Team")
+            if attributes["type"] == "User":
+                self._reviewer = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["reviewer"])
+            elif attributes["type"] == "Team":
+                self._reviewer = self._makeClassAttribute(github.Team.Team, attributes["reviewer"])
+        if "type" in attributes:  # pragma no branch
+            self._type = self._makeStringAttribute(attributes["type"])
+
+
+class ReviewerParams:
+    """
+    This class presents reviewers as can be configured for an Environment.
+    """
+
+    def __init__(self, type_: str, id_: int):
+        assert isinstance(type_, str) and type_ in ("User", "Team")
+        assert isinstance(id_, int)
+        self.type = type_
+        self.id = id_
+
+    def _asdict(self) -> dict:
+        return {
+            "type": self.type,
+            "id": self.id,
+        }

venv/lib/python3.10/site-packages/github/Event.py

@@ -0,0 +1,126 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2013 martinqt <m.ki2@laposte.net>                                  #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import github.GithubObject
+import github.NamedUser
+import github.Organization
+import github.Repository
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class Event(NonCompletableGithubObject):
+    """
+    This class represents Events.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/activity#events
+
+    The OpenAPI schema can be found at
+    - /components/schemas/event
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._actor: Attribute[github.NamedUser.NamedUser] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._id: Attribute[str] = NotSet
+        self._org: Attribute[github.Organization.Organization] = NotSet
+        self._payload: Attribute[dict[str, Any]] = NotSet
+        self._public: Attribute[bool] = NotSet
+        self._repo: Attribute[github.Repository.Repository] = NotSet
+        self._type: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value, "type": self._type.value})
+
+    @property
+    def actor(self) -> github.NamedUser.NamedUser:
+        return self._actor.value
+
+    @property
+    def created_at(self) -> datetime:
+        return self._created_at.value
+
+    @property
+    def id(self) -> str:
+        return self._id.value
+
+    @property
+    def org(self) -> github.Organization.Organization:
+        return self._org.value
+
+    @property
+    def payload(self) -> dict[str, Any]:
+        return self._payload.value
+
+    @property
+    def public(self) -> bool:
+        return self._public.value
+
+    @property
+    def repo(self) -> github.Repository.Repository:
+        return self._repo.value
+
+    @property
+    def type(self) -> str:
+        return self._type.value
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "actor" in attributes:  # pragma no branch
+            self._actor = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["actor"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeStringAttribute(attributes["id"])
+        if "org" in attributes:  # pragma no branch
+            self._org = self._makeClassAttribute(github.Organization.Organization, attributes["org"])
+        if "payload" in attributes:  # pragma no branch
+            self._payload = self._makeDictAttribute(attributes["payload"])
+        if "public" in attributes:  # pragma no branch
+            self._public = self._makeBoolAttribute(attributes["public"])
+        if "repo" in attributes:  # pragma no branch
+            self._repo = self._makeClassAttribute(github.Repository.Repository, attributes["repo"])
+        if "type" in attributes:  # pragma no branch
+            self._type = self._makeStringAttribute(attributes["type"])

venv/lib/python3.10/site-packages/github/File.py

@@ -0,0 +1,138 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Jeffrey Melvin <jeffrey.melvin@workiva.com>                   #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2017 Simon <spam@esemi.ru>                                         #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from typing import Any, Dict
+
+from github.GithubObject import Attribute, NonCompletableGithubObject, NotSet
+
+
+class File(NonCompletableGithubObject):
+    """
+    This class represents Files.
+
+    The OpenAPI schema can be found at
+    - /components/schemas/diff-entry
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._additions: Attribute[int] = NotSet
+        self._blob_url: Attribute[str] = NotSet
+        self._changes: Attribute[int] = NotSet
+        self._contents_url: Attribute[str] = NotSet
+        self._deletions: Attribute[int] = NotSet
+        self._filename: Attribute[str] = NotSet
+        self._patch: Attribute[str] = NotSet
+        self._previous_filename: Attribute[str] = NotSet
+        self._raw_url: Attribute[str] = NotSet
+        self._sha: Attribute[str] = NotSet
+        self._status: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"sha": self._sha.value, "filename": self._filename.value})
+
+    @property
+    def additions(self) -> int:
+        return self._additions.value
+
+    @property
+    def blob_url(self) -> str:
+        return self._blob_url.value
+
+    @property
+    def changes(self) -> int:
+        return self._changes.value
+
+    @property
+    def contents_url(self) -> str:
+        return self._contents_url.value
+
+    @property
+    def deletions(self) -> int:
+        return self._deletions.value
+
+    @property
+    def filename(self) -> str:
+        return self._filename.value
+
+    @property
+    def patch(self) -> str:
+        return self._patch.value
+
+    @property
+    def previous_filename(self) -> str:
+        return self._previous_filename.value
+
+    @property
+    def raw_url(self) -> str:
+        return self._raw_url.value
+
+    @property
+    def sha(self) -> str:
+        return self._sha.value
+
+    @property
+    def status(self) -> str:
+        return self._status.value
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "additions" in attributes:  # pragma no branch
+            self._additions = self._makeIntAttribute(attributes["additions"])
+        if "blob_url" in attributes:  # pragma no branch
+            self._blob_url = self._makeStringAttribute(attributes["blob_url"])
+        if "changes" in attributes:  # pragma no branch
+            self._changes = self._makeIntAttribute(attributes["changes"])
+        if "contents_url" in attributes:  # pragma no branch
+            self._contents_url = self._makeStringAttribute(attributes["contents_url"])
+        if "deletions" in attributes:  # pragma no branch
+            self._deletions = self._makeIntAttribute(attributes["deletions"])
+        if "filename" in attributes:  # pragma no branch
+            self._filename = self._makeStringAttribute(attributes["filename"])
+        if "patch" in attributes:  # pragma no branch
+            self._patch = self._makeStringAttribute(attributes["patch"])
+        if "previous_filename" in attributes:  # pragma no branch
+            self._previous_filename = self._makeStringAttribute(attributes["previous_filename"])
+        if "raw_url" in attributes:  # pragma no branch
+            self._raw_url = self._makeStringAttribute(attributes["raw_url"])
+        if "sha" in attributes:  # pragma no branch
+            self._sha = self._makeStringAttribute(attributes["sha"])
+        if "status" in attributes:  # pragma no branch
+            self._status = self._makeStringAttribute(attributes["status"])

venv/lib/python3.10/site-packages/github/Gist.py

@@ -0,0 +1,335 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Steve English <steve.english@navetas.com>                     #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Dale Jung <dale@dalejung.com>                                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2018 羽 <Just4test@users.noreply.github.com>                        #
+# Copyright 2019 Jon Dufresne <jon.dufresne@gmail.com>                         #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Mark Walker <mark.walker@realbuzz.com>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import github.GistComment
+import github.GistFile
+import github.GistHistoryState
+import github.GithubObject
+import github.NamedUser
+import github.PaginatedList
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet, Opt, _NotSetType, is_defined, is_optional
+from github.PaginatedList import PaginatedList
+
+if TYPE_CHECKING:
+    from github.GistComment import GistComment
+    from github.GistHistoryState import GistHistoryState
+    from github.InputFileContent import InputFileContent
+
+
+class Gist(CompletableGithubObject):
+    """
+    This class represents Gists.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/gists
+
+    The OpenAPI schema can be found at
+    - /components/schemas/base-gist
+    - /components/schemas/gist-simple
+    - /components/schemas/gist-simple/properties/fork_of
+    - /components/schemas/gist-simple/properties/forks/items
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._comments: Attribute[int] = NotSet
+        self._comments_url: Attribute[str] = NotSet
+        self._commits_url: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._description: Attribute[str] = NotSet
+        self._files: Attribute[dict[str, github.GistFile.GistFile]] = NotSet
+        self._fork_of: Attribute[Gist] = NotSet
+        self._forks: Attribute[list[Gist]] = NotSet
+        self._forks_url: Attribute[str] = NotSet
+        self._git_pull_url: Attribute[str] = NotSet
+        self._git_push_url: Attribute[str] = NotSet
+        self._history: Attribute[list[GistHistoryState]] = NotSet
+        self._html_url: Attribute[str] = NotSet
+        self._id: Attribute[str] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._owner: Attribute[github.NamedUser.NamedUser] = NotSet
+        self._public: Attribute[bool] = NotSet
+        self._truncated: Attribute[bool] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+        self._user: Attribute[github.NamedUser.NamedUser] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value})
+
+    @property
+    def comments(self) -> int:
+        self._completeIfNotSet(self._comments)
+        return self._comments.value
+
+    @property
+    def comments_url(self) -> str:
+        self._completeIfNotSet(self._comments_url)
+        return self._comments_url.value
+
+    @property
+    def commits_url(self) -> str:
+        self._completeIfNotSet(self._commits_url)
+        return self._commits_url.value
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def description(self) -> str:
+        self._completeIfNotSet(self._description)
+        return self._description.value
+
+    @property
+    def files(self) -> dict[str, github.GistFile.GistFile]:
+        self._completeIfNeeded()
+        return self._files.value
+
+    @property
+    def fork_of(self) -> github.Gist.Gist:
+        self._completeIfNotSet(self._fork_of)
+        return self._fork_of.value
+
+    @property
+    def forks(self) -> list[Gist]:
+        self._completeIfNotSet(self._forks)
+        return self._forks.value
+
+    @property
+    def forks_url(self) -> str:
+        self._completeIfNotSet(self._forks_url)
+        return self._forks_url.value
+
+    @property
+    def git_pull_url(self) -> str:
+        self._completeIfNotSet(self._git_pull_url)
+        return self._git_pull_url.value
+
+    @property
+    def git_push_url(self) -> str:
+        self._completeIfNotSet(self._git_push_url)
+        return self._git_push_url.value
+
+    @property
+    def history(self) -> list[GistHistoryState]:
+        self._completeIfNotSet(self._history)
+        return self._history.value
+
+    @property
+    def html_url(self) -> str:
+        self._completeIfNotSet(self._html_url)
+        return self._html_url.value
+
+    @property
+    def id(self) -> str:
+        self._completeIfNotSet(self._id)
+        return self._id.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def owner(self) -> github.NamedUser.NamedUser:
+        self._completeIfNotSet(self._owner)
+        return self._owner.value
+
+    @property
+    def public(self) -> bool:
+        self._completeIfNotSet(self._public)
+        return self._public.value
+
+    @property
+    def truncated(self) -> bool:
+        self._completeIfNotSet(self._truncated)
+        return self._truncated.value
+
+    @property
+    def updated_at(self) -> datetime:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    @property
+    def user(self) -> github.NamedUser.NamedUser:
+        self._completeIfNotSet(self._user)
+        return self._user.value
+
+    def create_comment(self, body: str) -> GistComment:
+        """
+        :calls: `POST /gists/{gist_id}/comments <https://docs.github.com/en/rest/reference/gists#comments>`_
+        """
+        assert isinstance(body, str), body
+        post_parameters = {
+            "body": body,
+        }
+        headers, data = self._requester.requestJsonAndCheck("POST", f"{self.url}/comments", input=post_parameters)
+        return github.GistComment.GistComment(self._requester, headers, data, completed=True)
+
+    def create_fork(self) -> Gist:
+        """
+        :calls: `POST /gists/{id}/forks <https://docs.github.com/en/rest/reference/gists>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("POST", f"{self.url}/forks")
+        return Gist(self._requester, headers, data, completed=True)
+
+    def delete(self) -> None:
+        """
+        :calls: `DELETE /gists/{id} <https://docs.github.com/en/rest/reference/gists>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("DELETE", self.url)
+
+    def edit(self, description: Opt[str] = NotSet, files: Opt[dict[str, InputFileContent | None]] = NotSet) -> None:
+        """
+        :calls: `PATCH /gists/{id} <https://docs.github.com/en/rest/reference/gists>`_
+        """
+        assert is_optional(description, str), description
+        # limitation of `TypeGuard`
+        assert isinstance(files, _NotSetType) or all(
+            element is None or isinstance(element, github.InputFileContent) for element in files.values()
+        ), files
+        post_parameters: dict[str, Any] = {}
+        if is_defined(description):
+            post_parameters["description"] = description
+        if is_defined(files):
+            post_parameters["files"] = {key: None if value is None else value._identity for key, value in files.items()}
+        headers, data = self._requester.requestJsonAndCheck("PATCH", self.url, input=post_parameters)
+        self._useAttributes(data)
+
+    def get_comment(self, id: int) -> GistComment:
+        """
+        :calls: `GET /gists/{gist_id}/comments/{id} <https://docs.github.com/en/rest/reference/gists#comments>`_
+        """
+        assert isinstance(id, int), id
+        headers, data = self._requester.requestJsonAndCheck("GET", f"{self.url}/comments/{id}")
+        return github.GistComment.GistComment(self._requester, headers, data, completed=True)
+
+    def get_comments(self) -> PaginatedList[GistComment]:
+        """
+        :calls: `GET /gists/{gist_id}/comments <https://docs.github.com/en/rest/reference/gists#comments>`_
+        """
+        return PaginatedList(
+            github.GistComment.GistComment,
+            self._requester,
+            f"{self.url}/comments",
+            None,
+        )
+
+    def is_starred(self) -> bool:
+        """
+        :calls: `GET /gists/{id}/star <https://docs.github.com/en/rest/reference/gists>`_
+        """
+        status, headers, data = self._requester.requestJson("GET", f"{self.url}/star")
+        return status == 204
+
+    def reset_starred(self) -> None:
+        """
+        :calls: `DELETE /gists/{id}/star <https://docs.github.com/en/rest/reference/gists>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("DELETE", f"{self.url}/star")
+
+    def set_starred(self) -> None:
+        """
+        :calls: `PUT /gists/{id}/star <https://docs.github.com/en/rest/reference/gists>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("PUT", f"{self.url}/star")
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "comments" in attributes:  # pragma no branch
+            self._comments = self._makeIntAttribute(attributes["comments"])
+        if "comments_url" in attributes:  # pragma no branch
+            self._comments_url = self._makeStringAttribute(attributes["comments_url"])
+        if "commits_url" in attributes:  # pragma no branch
+            self._commits_url = self._makeStringAttribute(attributes["commits_url"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "description" in attributes:  # pragma no branch
+            self._description = self._makeStringAttribute(attributes["description"])
+        if "files" in attributes:  # pragma no branch
+            self._files = self._makeDictOfStringsToClassesAttribute(github.GistFile.GistFile, attributes["files"])
+        if "fork_of" in attributes:  # pragma no branch
+            self._fork_of = self._makeClassAttribute(Gist, attributes["fork_of"])
+        if "forks" in attributes:  # pragma no branch
+            self._forks = self._makeListOfClassesAttribute(Gist, attributes["forks"])
+        if "forks_url" in attributes:  # pragma no branch
+            self._forks_url = self._makeStringAttribute(attributes["forks_url"])
+        if "git_pull_url" in attributes:  # pragma no branch
+            self._git_pull_url = self._makeStringAttribute(attributes["git_pull_url"])
+        if "git_push_url" in attributes:  # pragma no branch
+            self._git_push_url = self._makeStringAttribute(attributes["git_push_url"])
+        if "history" in attributes:  # pragma no branch
+            self._history = self._makeListOfClassesAttribute(
+                github.GistHistoryState.GistHistoryState, attributes["history"]
+            )
+        if "html_url" in attributes:  # pragma no branch
+            self._html_url = self._makeStringAttribute(attributes["html_url"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeStringAttribute(attributes["id"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "owner" in attributes:  # pragma no branch
+            self._owner = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["owner"])
+        if "public" in attributes:  # pragma no branch
+            self._public = self._makeBoolAttribute(attributes["public"])
+        if "truncated" in attributes:  # pragma no branch
+            self._truncated = self._makeBoolAttribute(attributes["truncated"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])
+        if "user" in attributes:  # pragma no branch
+            self._user = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["user"])

venv/lib/python3.10/site-packages/github/GistComment.py

@@ -0,0 +1,150 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2021 Mark Walker <mark.walker@realbuzz.com>                        #
+# Copyright 2021 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2025 Enrico Minack <github@enrico.minack.dev>                      #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub 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 Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import github.GithubObject
+import github.NamedUser
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+
+
+class GistComment(CompletableGithubObject):
+    """
+    This class represents GistComments.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/gists#comments
+
+    The OpenAPI schema can be found at
+    - /components/schemas/gist-comment
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._author_association: Attribute[str] = NotSet
+        self._body: Attribute[str] = NotSet
+        self._created_at: Attribute[datetime] = NotSet
+        self._id: Attribute[int] = NotSet
+        self._node_id: Attribute[str] = NotSet
+        self._updated_at: Attribute[datetime] = NotSet
+        self._url: Attribute[str] = NotSet
+        self._user: Attribute[github.NamedUser.NamedUser] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"id": self._id.value, "user": self._user.value})
+
+    @property
+    def author_association(self) -> str:
+        self._completeIfNotSet(self._author_association)
+        return self._author_association.value
+
+    @property
+    def body(self) -> str:
+        self._completeIfNotSet(self._body)
+        return self._body.value
+
+    @property
+    def created_at(self) -> datetime:
+        self._completeIfNotSet(self._created_at)
+        return self._created_at.value
+
+    @property
+    def id(self) -> int:
+        self._completeIfNotSet(self._id)
+        return self._id.value
+
+    @property
+    def node_id(self) -> str:
+        self._completeIfNotSet(self._node_id)
+        return self._node_id.value
+
+    @property
+    def updated_at(self) -> datetime:
+        self._completeIfNotSet(self._updated_at)
+        return self._updated_at.value
+
+    @property
+    def url(self) -> str:
+        self._completeIfNotSet(self._url)
+        return self._url.value
+
+    @property
+    def user(self) -> github.NamedUser.NamedUser:
+        self._completeIfNotSet(self._user)
+        return self._user.value
+
+    def delete(self) -> None:
+        """
+        :calls: `DELETE /gists/{gist_id}/comments/{id} <https://docs.github.com/en/rest/reference/gists#comments>`_
+        """
+        headers, data = self._requester.requestJsonAndCheck("DELETE", self.url)
+
+    def edit(self, body: str) -> None:
+        """
+        :calls: `PATCH /gists/{gist_id}/comments/{id} <https://docs.github.com/en/rest/reference/gists#comments>`_
+        """
+        assert isinstance(body, str), body
+        post_parameters = {
+            "body": body,
+        }
+        headers, data = self._requester.requestJsonAndCheck("PATCH", self.url, input=post_parameters)
+        self._useAttributes(data)
+
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
+        if "author_association" in attributes:  # pragma no branch
+            self._author_association = self._makeStringAttribute(attributes["author_association"])
+        if "body" in attributes:  # pragma no branch
+            self._body = self._makeStringAttribute(attributes["body"])
+        if "created_at" in attributes:  # pragma no branch
+            self._created_at = self._makeDatetimeAttribute(attributes["created_at"])
+        if "id" in attributes:  # pragma no branch
+            self._id = self._makeIntAttribute(attributes["id"])
+        if "node_id" in attributes:  # pragma no branch
+            self._node_id = self._makeStringAttribute(attributes["node_id"])
+        if "updated_at" in attributes:  # pragma no branch
+            self._updated_at = self._makeDatetimeAttribute(attributes["updated_at"])
+        if "url" in attributes:  # pragma no branch
+            self._url = self._makeStringAttribute(attributes["url"])
+        if "user" in attributes:  # pragma no branch
+            self._user = self._makeClassAttribute(github.NamedUser.NamedUser, attributes["user"])