0.3.3

0.3.3

* When fetching, pulling or pushing, and an error occours, it will not be reported on stdout anymore. However, if there is a fatal error, it will still result in a GitCommandError to be thrown. This goes hand in hand with improved fetch result parsing.

* Code Cleanup (in preparation for python 3 support)

* Applied autopep8 and cleaned up code

* Using python logging module instead of print statments to signal certain kinds of errors

0.3.2.1

if self.GIT_PYTHON_TRACE and (self.GIT_PYTHON_TRACE != 'full' or as_process):

print(' '.join(command))

# Allow the user to have the command executed in their working dir.

if with_keep_cwd or self._working_dir is None:

if self.GIT_PYTHON_TRACE == 'full':

cmdstr = " ".join(command)

if stderr_value:

print("%s -> %d; stdout: '%s'; stderr: '%s'" % (cmdstr, status, stdout_value, stderr_value))

elif stdout_value:

print("%s -> %d; stdout: '%s'" % (cmdstr, status, stdout_value))

else:

print("%s -> %d" % (cmdstr, status))

# END handle debug printing

if with_exceptions and status != 0:

raise

# END handle overridden variable

type(self).GIT_PYTHON_GIT_EXECUTABLE = self.git_exec_name_win

try:

return self.execute(make_call(), **_kwargs)

finally:

import warnings

msg = "WARNING: Automatically switched to use git.cmd as git executable"

msg += ", which reduces performance by ~70%."

msg += "Its recommended to put git.exe into the PATH or to "

msg += "set the %s " % self._git_exec_env_var

msg += "environment variable to the executable's location"

warnings.warn(msg)

# END print of warning

# END catch first failure

import re

import ConfigParser as cp

import inspect

from git.odict import OrderedDict

from git.util import LockFile

try:

try:

self.write()

except IOError as e:

print("Exception during destruction of GitConfigParser: %s" % str(e))

finally:

self._lock._release_lock()

try:

fp = open(file_object)

close_fp = True

except IOError:

continue

# END fp handling

import re

from objects.blob import Blob

from objects.util import mode_str_to_int

from gitdb.util import hex_to_bin

diff_method = Diff._index_from_patch_format

index = diff_method(self.repo, proc.stdout)

proc.wait()

return index

# handles

# :100644 100644 687099101... 37c5e30c8... M .gitignore

index = DiffIndex()

for line in stream:

if not line.startswith(":"):

from __future__ import absolute_import

from .base import *

from .typ import *

git_working_dir

)

import git.diff as diff

from git.exc import (

from git.objects.util import Serializable

from git.util import (

LazyMixin,

LockedFD,

join_path_native,

file_contents_ro,

to_native_path_linux,

)

from fun import (

for entry in self.entries.itervalues():

blob = entry.to_blob(self.repo)

blob.size = entry.size

output = (entry.stage, blob)

def add(self, items, force=True, fprogress=lambda *args: None, path_rewriter=None,

write=True):

"""Add files from the working tree, specific blobs or BaseIndexEntries

tree = self.write_tree()

return Commit.create_from_tree(self.repo, tree, message, parent_commits,

head, author=author, committer=committer)

@classmethod

def _flush_stdin_and_wait(cls, proc, ignore_stdout=False):

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:

S_IFDIR,

S_IFLNK,

S_ISLNK,

S_ISDIR,

S_IFMT,

S_IFREG,

path = read(path_size)

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 safe the effort

entries[(path, entry.stage)] = entry

# 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:]

# it exists in all branches, if 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))