0.3.4

Changelog

0.3.4 - Python 3 Support

* Internally, hexadecimal SHA1 are treated as ascii encoded strings. Binary SHA1 are treated as bytes.

* Id attribute of Commit objects is now `hexsha`, instead of `binsha`. The latter makes no sense in python 3 and I see no application of it anyway besides its artificial usage in test cases.

* **IMPORTANT**: If you were using the config_writer(), you implicitly relied on __del__ to work as expected to flush changes. To be sure changes are flushed under PY3, you will have to call the new `release()` method to trigger a flush. For some reason, __del__ is not called necessarily anymore when a symbol goes out of scope.

* The `Tree` now has a `.join('name')` method which is equivalent to `tree / 'name'`

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

import os

import sys

import logging

from subprocess import (

call,

Popen,

PIPE

)

from .util import (

LazyMixin,

stream_copy

)

from .exc import GitCommandError

from git.compat import (

string_types,

defenc,

PY3

)

execute_kwargs = ('istream', 'with_keep_cwd', 'with_extended_output',

'with_exceptions', 'as_process',

'output_stream')

status = self.proc.wait()

if status != 0:

raise GitCommandError(self.args, status, self.proc.stderr.read().decode(defenc))

# END status handling

return status

# END auto interrupt

# Wait for the process to return

status = 0

stdout_value = b''

stderr_value = b''

try:

if output_stream is None:

stdout_value, stderr_value = proc.communicate()

# strip trailing "\n"

if stdout_value.endswith(b"\n"):

stdout_value = stdout_value[:-1]

if stderr_value.endswith(b"\n"):

stderr_value = stderr_value[:-1]

status = proc.returncode

else:

stream_copy(proc.stdout, output_stream, self.max_chunk_size)

stdout_value = output_stream

stderr_value = proc.stderr.read()

# strip trailing "\n"

if stderr_value.endswith(b"\n"):

stderr_value = stderr_value[:-1]

status = proc.wait()

# END stdout handling

if self.GIT_PYTHON_TRACE == 'full':

cmdstr = " ".join(command)

if stderr_value:

log.info("%s -> %d; stdout: '%s'; stderr: '%s'",

cmdstr, status, stdout_value.decode(defenc), stderr_value.decode(defenc))

elif stdout_value:

log.info("%s -> %d; stdout: '%s'", cmdstr, status, stdout_value.decode(defenc))

else:

log.info("%s -> %d", cmdstr, status)

# END handle debug printing

else:

raise GitCommandError(command, status, stderr_value)

if isinstance(stdout_value, bytes): # could also be output_stream

stdout_value = stdout_value.decode(defenc)

# Allow access to the command's status code

if with_extended_output:

return (status, stdout_value, stderr_value.decode(defenc))

else:

return stdout_value

@classmethod

def __unpack_args(cls, arg_list):

if not isinstance(arg_list, (list, tuple)):

# This is just required for unicode conversion, as subprocess can't handle it

# However, in any other case, passing strings (usually utf-8 encoded) is totally fine

if not PY3 and isinstance(arg_list, unicode):

return [arg_list.encode(defenc)]

return [str(arg_list)]

outlist = list()

for arg in arg_list:

if isinstance(arg_list, (list, tuple)):

outlist.extend(cls.__unpack_args(arg))

elif not PY3 and isinstance(arg_list, unicode):

outlist.append(arg_list.encode(defenc))

# END recursion

else:

outlist.append(str(arg))

# Prepare the argument list

opt_args = self.transform_kwargs(**kwargs)

ext_args = self.__unpack_args([a for a in args if a is not None])

args = opt_args + ext_args

def make_call():

raise ValueError("Failed to parse header: %r" % header_line)

return (tokens[0], tokens[1], int(tokens[2]))

def _prepare_ref(self, ref):

# required for command to separate refs on stdin, as bytes

refstr = ref

if isinstance(ref, bytes):

# Assume 40 bytes hexsha - bin-to-ascii for some reason returns bytes, not text

refstr = ref.decode('ascii')

elif not isinstance(ref, string_types):

refstr = str(ref) # could be ref-object

if not refstr.endswith("\n"):

refstr += "\n"

return refstr.encode(defenc)

def _get_persistent_cmd(self, attr_name, cmd_name, *args, **kwargs):

cur_val = getattr(self, attr_name)

if cur_val is not None:

return cur_val

return cmd

def __get_object_header(self, cmd, ref):

cmd.stdin.write(self._prepare_ref(ref))

cmd.stdin.flush()

return self._parse_object_header(cmd.stdout.readline())

cmd = self._get_persistent_cmd("cat_file_header", "cat_file", batch_check=True)

return self.__get_object_header(cmd, ref)

def get_object_data(self, ref):

cmd = self._get_persistent_cmd("cat_file_all", "cat_file", batch=True)

hexsha, typename, size = self.__get_object_header(cmd, ref)

return (hexsha, typename, size, self.CatFileContentStream(size, cmd.stdout))

import sys

from gitdb.utils.compat import (

PY3,

xrange,

MAXSIZE,

izip,

)

from gitdb.utils.encoding import (

string_types,

text_type,

force_bytes,

force_text

)

defenc = sys.getdefaultencoding()

if PY3:

import io

FileType = io.IOBase

def byte_ord(b):

return b

def bchr(n):

return bytes([n])

def mviter(d):

return d.values()

else:

FileType = file

# usually, this is just ascii, which might not enough for our encoding needs

# Unless it's set specifically, we override it to be utf-8

if defenc == 'ascii':

defenc = 'utf-8'

byte_ord = ord

bchr = chr

def mviter(d):

return d.itervalues()

def with_metaclass(meta, *bases):

"""copied from https://github.com/Byron/bcore/blob/master/src/python/butility/future.py#L15"""

class metaclass(meta):

__call__ = type.__call__

__init__ = type.__init__

def __new__(cls, name, nbases, d):

if nbases is None:

return type.__new__(cls, name, (), d)

# There may be clients who rely on this attribute to be set to a reasonable value, which is why

# we set the __metaclass__ attribute explicitly

if not PY3 and '___metaclass__' not in d:

d['__metaclass__'] = meta

# end

return meta(name, bases, d)

# end

# end metaclass

return metaclass(meta.__name__ + 'Helper', None, {})

# end handle py2