GitPython/git/objects/commit.py at main · shubibees/GitPython · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

# This module is part of GitPython and is released under the

# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/

__all__ = ["Commit"]

from collections import defaultdict

import datetime

from io import BytesIO

import logging

import os

import re

from subprocess import Popen, PIPE

import sys

from time import altzone, daylight, localtime, time, timezone

import warnings

from gitdb import IStream

from git.cmd import Git

from git.diff import Diffable

from git.util import Actor, Stats, finalize_process, hex_to_bin

from . import base

from .tree import Tree

from .util import (

Serializable,

TraversableIterableObj,

altz_to_utctz_str,

from_timestamp,

parse_actor_and_date,

parse_date,

)

# typing ------------------------------------------------------------------

from typing import (

Any,

Dict,

IO,

Iterator,

List,

Sequence,

Tuple,

TYPE_CHECKING,

Union,

cast,

)

if sys.version_info >= (3, 8):

from typing import Literal

else:

from typing_extensions import Literal

from git.types import PathLike

if TYPE_CHECKING:

from git.refs import SymbolicReference

from git.repo import Repo

# ------------------------------------------------------------------------

_logger = logging.getLogger(__name__)

class Commit(base.Object, TraversableIterableObj, Diffable, Serializable):

"""Wraps a git commit object.

See :manpage:`gitglossary(7)` on "commit object":

https://git-scm.com/docs/gitglossary#def_commit_object

:note:

This class will act lazily on some of its attributes and will query the value on

demand only if it involves calling the git binary.

"""

# ENVIRONMENT VARIABLES

# Read when creating new commits.

env_author_date = "GIT_AUTHOR_DATE"

env_committer_date = "GIT_COMMITTER_DATE"

# CONFIGURATION KEYS

conf_encoding = "i18n.commitencoding"

# INVARIANTS

default_encoding = "UTF-8"

type: Literal["commit"] = "commit"

__slots__ = (

"tree",

"author",

"authored_date",

"author_tz_offset",

"committer",

"committed_date",

"committer_tz_offset",

"message",

"parents",

"encoding",

"gpgsig",

)

_id_attribute_ = "hexsha"

parents: Sequence["Commit"]

def __init__(

self,

repo: "Repo",

binsha: bytes,

tree: Union[Tree, None] = None,

author: Union[Actor, None] = None,

authored_date: Union[int, None] = None,

author_tz_offset: Union[None, float] = None,

committer: Union[Actor, None] = None,

committed_date: Union[int, None] = None,

committer_tz_offset: Union[None, float] = None,

message: Union[str, bytes, None] = None,

parents: Union[Sequence["Commit"], None] = None,

encoding: Union[str, None] = None,

gpgsig: Union[str, None] = None,

) -> None:

"""Instantiate a new :class:`Commit`. All keyword arguments taking ``None`` as

default will be implicitly set on first query.

:param binsha:

20 byte sha1.

:param tree:

A :class:`~git.objects.tree.Tree` object.

:param author:

The author :class:`~git.util.Actor` object.

:param authored_date: int_seconds_since_epoch

The authored DateTime - use :func:`time.gmtime` to convert it into a

different format.

:param author_tz_offset: int_seconds_west_of_utc

The timezone that the `authored_date` is in.

:param committer:

The committer string, as an :class:`~git.util.Actor` object.

:param committed_date: int_seconds_since_epoch

The committed DateTime - use :func:`time.gmtime` to convert it into a

different format.

:param committer_tz_offset: int_seconds_west_of_utc

The timezone that the `committed_date` is in.

:param message: string

The commit message.

:param encoding: string

Encoding of the message, defaults to UTF-8.

:param parents:

List or tuple of :class:`Commit` objects which are our parent(s) in the

commit dependency graph.

:return:

:class:`Commit`

:note:

Timezone information is in the same format and in the same sign as what

:func:`time.altzone` returns. The sign is inverted compared to git's UTC

timezone.

"""

super().__init__(repo, binsha)

self.binsha = binsha

if tree is not None:

assert isinstance(tree, Tree), "Tree needs to be a Tree instance, was %s" % type(tree)

if tree is not None:

self.tree = tree

if author is not None:

self.author = author

if authored_date is not None:

self.authored_date = authored_date

if author_tz_offset is not None:

self.author_tz_offset = author_tz_offset

if committer is not None:

self.committer = committer

if committed_date is not None:

self.committed_date = committed_date

if committer_tz_offset is not None:

self.committer_tz_offset = committer_tz_offset

if message is not None:

self.message = message

if parents is not None:

self.parents = parents

if encoding is not None:

self.encoding = encoding

if gpgsig is not None:

self.gpgsig = gpgsig

@classmethod

def _get_intermediate_items(cls, commit: "Commit") -> Tuple["Commit", ...]:

return tuple(commit.parents)

@classmethod

def _calculate_sha_(cls, repo: "Repo", commit: "Commit") -> bytes:

"""Calculate the sha of a commit.

:param repo:

:class:`~git.repo.base.Repo` object the commit should be part of.

:param commit:

:class:`Commit` object for which to generate the sha.

"""

stream = BytesIO()

commit._serialize(stream)

streamlen = stream.tell()

stream.seek(0)

istream = repo.odb.store(IStream(cls.type, streamlen, stream))

return istream.binsha

def replace(self, **kwargs: Any) -> "Commit":

"""Create new commit object from an existing commit object.

Any values provided as keyword arguments will replace the corresponding

attribute in the new object.

"""

attrs = {k: getattr(self, k) for k in self.__slots__}

for attrname in kwargs:

if attrname not in self.__slots__:

raise ValueError("invalid attribute name")

attrs.update(kwargs)

new_commit = self.__class__(self.repo, self.NULL_BIN_SHA, **attrs)

new_commit.binsha = self._calculate_sha_(self.repo, new_commit)

return new_commit

def _set_cache_(self, attr: str) -> None:

if attr in Commit.__slots__:

# Read the data in a chunk, its faster - then provide a file wrapper.

_binsha, _typename, self.size, stream = self.repo.odb.stream(self.binsha)

self._deserialize(BytesIO(stream.read()))

else:

super()._set_cache_(attr)

# END handle attrs

@property

def authored_datetime(self) -> datetime.datetime:

return from_timestamp(self.authored_date, self.author_tz_offset)

@property

def committed_datetime(self) -> datetime.datetime:

return from_timestamp(self.committed_date, self.committer_tz_offset)

@property

def summary(self) -> Union[str, bytes]:

""":return: First line of the commit message"""

if isinstance(self.message, str):

return self.message.split("\n", 1)[0]

else:

return self.message.split(b"\n", 1)[0]

def count(self, paths: Union[PathLike, Sequence[PathLike]] = "", **kwargs: Any) -> int:

"""Count the number of commits reachable from this commit.

:param paths:

An optional path or a list of paths restricting the return value to commits

actually containing the paths.

:param kwargs:

Additional options to be passed to :manpage:`git-rev-list(1)`. They must not

alter the output style of the command, or parsing will yield incorrect

results.

:return:

An int defining the number of reachable commits

"""

# Yes, it makes a difference whether empty paths are given or not in our case as

# the empty paths version will ignore merge commits for some reason.

if paths:

return len(self.repo.git.rev_list(self.hexsha, "--", paths, **kwargs).splitlines())

return len(self.repo.git.rev_list(self.hexsha, **kwargs).splitlines())

@property

def name_rev(self) -> str:

"""

:return:

String describing the commits hex sha based on the closest

`~git.refs.reference.Reference`.

:note:

Mostly useful for UI purposes.

"""

return self.repo.git.name_rev(self)

@classmethod

def iter_items(

cls,

repo: "Repo",

rev: Union[str, "Commit", "SymbolicReference"],

paths: Union[PathLike, Sequence[PathLike]] = "",

**kwargs: Any,

) -> Iterator["Commit"]:

R"""Find all commits matching the given criteria.

:param repo:

The :class:`~git.repo.base.Repo`.

:param rev:

Revision specifier. See :manpage:`git-rev-parse(1)` for viable options.

:param paths:

An optional path or list of paths. If set only :class:`Commit`\s that

include the path or paths will be considered.

:param kwargs:

Optional keyword arguments to :manpage:`git-rev-list(1)` where:

* ``max_count`` is the maximum number of commits to fetch.

* ``skip`` is the number of commits to skip.

* ``since`` selects all commits since some date, e.g. ``"1970-01-01"``.

:return:

Iterator yielding :class:`Commit` items.

"""

if "pretty" in kwargs:

raise ValueError("--pretty cannot be used as parsing expects single sha's only")

# END handle pretty

# Use -- in all cases, to prevent possibility of ambiguous arguments.

# See https://github.com/gitpython-developers/GitPython/issues/264.

args_list: List[PathLike] = ["--"]

if paths:

paths_tup: Tuple[PathLike, ...]

if isinstance(paths, (str, os.PathLike)):

paths_tup = (paths,)

else:

paths_tup = tuple(paths)

args_list.extend(paths_tup)

# END if paths

proc = repo.git.rev_list(rev, args_list, as_process=True, **kwargs)

return cls._iter_from_process_or_stream(repo, proc)

def iter_parents(self, paths: Union[PathLike, Sequence[PathLike]] = "", **kwargs: Any) -> Iterator["Commit"]:

R"""Iterate _all_ parents of this commit.

:param paths:

Optional path or list of paths limiting the :class:`Commit`\s to those that

contain at least one of the paths.

:param kwargs:

All arguments allowed by :manpage:`git-rev-list(1)`.

:return:

Iterator yielding :class:`Commit` objects which are parents of ``self``

"""

# skip ourselves

skip = kwargs.get("skip", 1)

if skip == 0: # skip ourselves

skip = 1

kwargs["skip"] = skip

return self.iter_items(self.repo, self, paths, **kwargs)

@property

def stats(self) -> Stats:

"""Create a git stat from changes between this commit and its first parent

or from all changes done if this is the very first commit.

:return:

:class:`Stats`

"""

def process_lines(lines: List[str]) -> str:

text = ""

for file_info, line in zip(lines, lines[len(lines) // 2 :]):

change_type = file_info.split("\t")[0][-1]

(insertions, deletions, filename) = line.split("\t")

text += "%s\t%s\t%s\t%s\n" % (change_type, insertions, deletions, filename)

return text

if not self.parents:

lines = self.repo.git.diff_tree(

self.hexsha, "--", numstat=True, no_renames=True, root=True, raw=True

).splitlines()[1:]

text = process_lines(lines)

else:

lines = self.repo.git.diff(

self.parents[0].hexsha, self.hexsha, "--", numstat=True, no_renames=True, raw=True

).splitlines()

text = process_lines(lines)

return Stats._list_from_string(self.repo, text)

@property

def trailers(self) -> Dict[str, str]:

"""Deprecated. Get the trailers of the message as a dictionary.

:note:

This property is deprecated, please use either :attr:`trailers_list` or

:attr:`trailers_dict`.

:return:

Dictionary containing whitespace stripped trailer information.

Only contains the latest instance of each trailer key.

"""

warnings.warn(

"Commit.trailers is deprecated, use Commit.trailers_list or Commit.trailers_dict instead",

DeprecationWarning,

stacklevel=2,

)

return {k: v[0] for k, v in self.trailers_dict.items()}

@property

def trailers_list(self) -> List[Tuple[str, str]]:

"""Get the trailers of the message as a list.

Git messages can contain trailer information that are similar to :rfc:`822`

e-mail headers. See :manpage:`git-interpret-trailers(1)`.

This function calls ``git interpret-trailers --parse`` onto the message to

extract the trailer information, returns the raw trailer data as a list.

Valid message with trailer::

Subject line

some body information

another information

key1: value1.1

key1: value1.2

key2 : value 2 with inner spaces

Returned list will look like this::

[

("key1", "value1.1"),

("key1", "value1.2"),

("key2", "value 2 with inner spaces"),

]

:return:

List containing key-value tuples of whitespace stripped trailer information.

"""

cmd = ["git", "interpret-trailers", "--parse"]

proc: Git.AutoInterrupt = self.repo.git.execute( # type: ignore[call-overload]

cmd,

as_process=True,

istream=PIPE,

)

trailer: str = proc.communicate(str(self.message).encode())[0].decode("utf8")

trailer = trailer.strip()

if not trailer:

return []

trailer_list = []

for t in trailer.split("\n"):

key, val = t.split(":", 1)

trailer_list.append((key.strip(), val.strip()))

return trailer_list

@property

def trailers_dict(self) -> Dict[str, List[str]]:

"""Get the trailers of the message as a dictionary.

Git messages can contain trailer information that are similar to :rfc:`822`

e-mail headers. See :manpage:`git-interpret-trailers(1)`.

This function calls ``git interpret-trailers --parse`` onto the message to

extract the trailer information. The key value pairs are stripped of leading and

trailing whitespaces before they get saved into a dictionary.

Valid message with trailer::

Subject line

some body information

another information

key1: value1.1

key1: value1.2

key2 : value 2 with inner spaces

Returned dictionary will look like this::

{

"key1": ["value1.1", "value1.2"],

"key2": ["value 2 with inner spaces"],

}

:return:

Dictionary containing whitespace stripped trailer information, mapping

trailer keys to a list of their corresponding values.

"""

d = defaultdict(list)

for key, val in self.trailers_list:

d[key].append(val)

return dict(d)

@classmethod

def _iter_from_process_or_stream(cls, repo: "Repo", proc_or_stream: Union[Popen, IO]) -> Iterator["Commit"]:

"""Parse out commit information into a list of :class:`Commit` objects.

We expect one line per commit, and parse the actual commit information directly

from our lighting fast object database.

:param proc:

:manpage:`git-rev-list(1)` process instance - one sha per line.

:return:

Iterator supplying :class:`Commit` objects

"""

# def is_proc(inp) -> TypeGuard[Popen]:

# return hasattr(proc_or_stream, 'wait') and not hasattr(proc_or_stream, 'readline')

# def is_stream(inp) -> TypeGuard[IO]:

# return hasattr(proc_or_stream, 'readline')

if hasattr(proc_or_stream, "wait"):

proc_or_stream = cast(Popen, proc_or_stream)

if proc_or_stream.stdout is not None:

stream = proc_or_stream.stdout

elif hasattr(proc_or_stream, "readline"):

proc_or_stream = cast(IO, proc_or_stream) # type: ignore[redundant-cast]

stream = proc_or_stream

readline = stream.readline

while True:

line = readline()

if not line:

break

hexsha = line.strip()

if len(hexsha) > 40:

# Split additional information, as returned by bisect for instance.

hexsha, _ = line.split(None, 1)

# END handle extra info

assert len(hexsha) == 40, "Invalid line: %s" % hexsha

yield cls(repo, hex_to_bin(hexsha))

# END for each line in stream

# TODO: Review this - it seems process handling got a bit out of control due to

# many developers trying to fix the open file handles issue.

if hasattr(proc_or_stream, "wait"):

proc_or_stream = cast(Popen, proc_or_stream)

finalize_process(proc_or_stream)

@classmethod

def create_from_tree(

cls,

repo: "Repo",

tree: Union[Tree, str],

message: str,

parent_commits: Union[None, List["Commit"]] = None,

head: bool = False,

author: Union[None, Actor] = None,

committer: Union[None, Actor] = None,

author_date: Union[None, str, datetime.datetime] = None,

commit_date: Union[None, str, datetime.datetime] = None,

) -> "Commit":

"""Commit the given tree, creating a :class:`Commit` object.

:param repo:

:class:`~git.repo.base.Repo` object the commit should be part of.

:param tree:

:class:`~git.objects.tree.Tree` object or hex or bin sha.

The tree of the new commit.

:param message:

Commit message. It may be an empty string if no message is provided. It will

be converted to a string, in any case.

:param parent_commits:

Optional :class:`Commit` objects to use as parents for the new commit. If

empty list, the commit will have no parents at all and become a root commit.

If ``None``, the current head commit will be the parent of the new commit

object.

:param head:

If ``True``, the HEAD will be advanced to the new commit automatically.

Otherwise the HEAD will remain pointing on the previous commit. This could

lead to undesired results when diffing files.

:param author:

The name of the author, optional.

If unset, the repository configuration is used to obtain this value.

:param committer:

The name of the committer, optional.

If unset, the repository configuration is used to obtain this value.

:param author_date:

The timestamp for the author field.

:param commit_date:

The timestamp for the committer field.

:return:

:class:`Commit` object representing the new commit.

:note:

Additional information about the committer and author are taken from the

environment or from the git configuration. See :manpage:`git-commit-tree(1)`

for more information.

"""

if parent_commits is None:

try:

parent_commits = [repo.head.commit]

except ValueError:

# Empty repositories have no head commit.

parent_commits = []

# END handle parent commits

else:

for p in parent_commits:

if not isinstance(p, cls):

raise ValueError(f"Parent commit '{p!r}' must be of type {cls}")

# END check parent commit types

# END if parent commits are unset

# Retrieve all additional information, create a commit object, and serialize it.

# Generally:

# * Environment variables override configuration values.

# * Sensible defaults are set according to the git documentation.

# COMMITTER AND AUTHOR INFO

cr = repo.config_reader()

env = os.environ

committer = committer or Actor.committer(cr)

author = author or Actor.author(cr)

# PARSE THE DATES

unix_time = int(time())

is_dst = daylight and localtime().tm_isdst > 0

offset = altzone if is_dst else timezone

author_date_str = env.get(cls.env_author_date, "")

if author_date:

author_time, author_offset = parse_date(author_date)

elif author_date_str:

author_time, author_offset = parse_date(author_date_str)

else:

author_time, author_offset = unix_time, offset

# END set author time

committer_date_str = env.get(cls.env_committer_date, "")

if commit_date:

committer_time, committer_offset = parse_date(commit_date)

elif committer_date_str:

committer_time, committer_offset = parse_date(committer_date_str)

else:

committer_time, committer_offset = unix_time, offset

# END set committer time

# Assume UTF-8 encoding.

enc_section, enc_option = cls.conf_encoding.split(".")

conf_encoding = cr.get_value(enc_section, enc_option, cls.default_encoding)

if not isinstance(conf_encoding, str):

raise TypeError("conf_encoding could not be coerced to str")

# If the tree is no object, make sure we create one - otherwise the created

# commit object is invalid.

if isinstance(tree, str):

tree = repo.tree(tree)

# END tree conversion

# CREATE NEW COMMIT

new_commit = cls(

repo,

cls.NULL_BIN_SHA,

tree,

author,

author_time,

author_offset,

committer,

committer_time,

committer_offset,

message,

parent_commits,

conf_encoding,

)

new_commit.binsha = cls._calculate_sha_(repo, new_commit)

if head:

# Need late import here, importing git at the very beginning throws as

# well...

import git.refs

try:

repo.head.set_commit(new_commit, logmsg=message)

except ValueError:

# head is not yet set to the ref our HEAD points to.

# Happens on first commit.

master = git.refs.Head.create(

repo,

repo.head.ref,

new_commit,

logmsg="commit (initial): %s" % message,

)

repo.head.set_reference(master, logmsg="commit: Switching to %s" % master)

# END handle empty repositories

# END advance head handling

return new_commit

# { Serializable Implementation

def _serialize(self, stream: BytesIO) -> "Commit":

write = stream.write

write(("tree %s\n" % self.tree).encode("ascii"))

for p in self.parents:

write(("parent %s\n" % p).encode("ascii"))

a = self.author

aname = a.name

c = self.committer

fmt = "%s %s <%s> %s %s\n"

write(

(

fmt

% (

"author",

aname,

a.email,

self.authored_date,

altz_to_utctz_str(self.author_tz_offset),

)

).encode(self.encoding)

)

# Encode committer.

aname = c.name

write(

(

fmt

% (

"committer",

aname,

c.email,

self.committed_date,

altz_to_utctz_str(self.committer_tz_offset),

)

).encode(self.encoding)

)

if self.encoding != self.default_encoding:

write(("encoding %s\n" % self.encoding).encode("ascii"))

try:

if self.__getattribute__("gpgsig"):

write(b"gpgsig")

for sigline in self.gpgsig.rstrip("\n").split("\n"):

write((" " + sigline + "\n").encode("ascii"))

except AttributeError:

pass

write(b"\n")

# Write plain bytes, be sure its encoded according to our encoding.

if isinstance(self.message, str):

write(self.message.encode(self.encoding))

else:

write(self.message)

# END handle encoding

return self

def _deserialize(self, stream: BytesIO) -> "Commit":

readline = stream.readline

self.tree = Tree(self.repo, hex_to_bin(readline().split()[1]), Tree.tree_id << 12, "")

self.parents = []

next_line = None

while True:

parent_line = readline()

if not parent_line.startswith(b"parent"):

next_line = parent_line

break

# END abort reading parents

self.parents.append(type(self)(self.repo, hex_to_bin(parent_line.split()[-1].decode("ascii"))))

# END for each parent line

self.parents = tuple(self.parents)

# We don't know actual author encoding before we have parsed it, so keep the

# lines around.

author_line = next_line

committer_line = readline()

# We might run into one or more mergetag blocks, skip those for now.

next_line = readline()

while next_line.startswith(b"mergetag "):

next_line = readline()

while next_line.startswith(b" "):

next_line = readline()

# END skip mergetags

# Now we can have the encoding line, or an empty line followed by the optional

# message.

self.encoding = self.default_encoding

self.gpgsig = ""

# Read headers.

enc = next_line

buf = enc.strip()

while buf:

if buf[0:10] == b"encoding ":

self.encoding = buf[buf.find(b" ") + 1 :].decode(self.encoding, "ignore")

elif buf[0:7] == b"gpgsig ":

sig = buf[buf.find(b" ") + 1 :] + b"\n"

is_next_header = False

while True:

sigbuf = readline()

if not sigbuf:

break

if sigbuf[0:1] != b" ":

buf = sigbuf.strip()

is_next_header = True

break

sig += sigbuf[1:]

# END read all signature

self.gpgsig = sig.rstrip(b"\n").decode(self.encoding, "ignore")

if is_next_header:

continue

buf = readline().strip()

# Decode the author's name.

try:

(

self.author,

self.authored_date,

self.author_tz_offset,

) = parse_actor_and_date(author_line.decode(self.encoding, "replace"))

except UnicodeDecodeError:

_logger.error(

"Failed to decode author line '%s' using encoding %s",

author_line,

self.encoding,

exc_info=True,

)

try:

(

self.committer,

self.committed_date,

self.committer_tz_offset,

) = parse_actor_and_date(committer_line.decode(self.encoding, "replace"))

except UnicodeDecodeError:

_logger.error(

"Failed to decode committer line '%s' using encoding %s",

committer_line,

self.encoding,

exc_info=True,

)

# END handle author's encoding

# A stream from our data simply gives us the plain message.

# The end of our message stream is marked with a newline that we strip.

self.message = stream.read()

try:

self.message = self.message.decode(self.encoding, "replace")

except UnicodeDecodeError:

_logger.error(

"Failed to decode message '%s' using encoding %s",

self.message,

self.encoding,

exc_info=True,

)

# END exception handling

return self

# } END serializable implementation

@property

def co_authors(self) -> List[Actor]:

"""Search the commit message for any co-authors of this commit.

Details on co-authors:

https://github.blog/2018-01-29-commit-together-with-co-authors/

:return:

List of co-authors for this commit (as :class:`~git.util.Actor` objects).

"""

co_authors = []

if self.message:

results = re.findall(

r"^Co-authored-by: (.*) <(.*?)>$",

self.message,

re.MULTILINE,

)

for author in results:

co_authors.append(Actor(*author))

return co_authors

GitPython/git/objects/commit.py at main · shubibees/GitPython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

commit.py

Latest commit

History

Breadcrumbs

commit.py

File metadata and controls