The goals I have set for myself, in order, are as follows, all on branch 0.3.

* bring the test suite back online to work with the most commonly used git version

* merge all open pull requests, may there be a test-case or not, back. If something breaks, fix it if possible or let the contributor know

* conform git-python's structure and toolchain to the one used in my[other OSS projects](https://github.com/Byron/bcore)

* evaluate all open issues and close them if possible

* evaluate python 3.3 compatibility and establish it if possible

While that is happening, I will try hard to foster community around the project. This means being more responsive on the mailing list and in issues, as well as setting up clear guide lines about the[contribution](http://rfc.zeromq.org/spec:22) and maintenance workflow.

0.3.3

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

fromutilimport (

LazyMixin,

)

fromsubprocessimport (

call,

Popen,

)

from .utilimport (

LazyMixin,

)

from .excimportGitCommandError

fromgit.compatimport (

string_types,

defenc,

)

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

'with_exceptions','as_process',

'output_stream')

status=self.proc.wait()

ifstatus!=0:

raiseGitCommandError(self.args,status,self.proc.stderr.read())

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

try:

ifoutput_streamisNone:

stdout_value,stderr_value=proc.communicate()

ifstdout_value.endswith("\n"):

ifstdout_value.endswith(b"\n"):

stdout_value=stdout_value[:-1]

ifstderr_value.endswith("\n"):

ifstderr_value.endswith(b"\n"):

stderr_value=stderr_value[:-1]

status=proc.returncode

else:

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

stderr_value=proc.stderr.read()

ifstderr_value.endswith("\n"):

ifstderr_value.endswith(b"\n"):

stderr_value=stderr_value[:-1]

status=proc.wait()

ifself.GIT_PYTHON_TRACE=='full':

cmdstr=" ".join(command)

ifstderr_value:

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

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

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

elifstdout_value:

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

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

else:

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

else:

raiseGitCommandError(command,status,stderr_value)

ifisinstance(stdout_value,bytes):# could also be output_stream

stdout_value=stdout_value.decode(defenc)

ifwith_extended_output:

return (status,stdout_value,stderr_value)

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

else:

def__unpack_args(cls,arg_list):

ifnotisinstance(arg_list, (list,tuple)):

ifisinstance(arg_list,unicode):

return [arg_list.encode('utf-8')]

ifnotPY3andisinstance(arg_list,unicode):

return [arg_list.encode(defenc)]

return [str(arg_list)]

outlist=list()

forarginarg_list:

ifisinstance(arg_list, (list,tuple)):

outlist.extend(cls.__unpack_args(arg))

elifisinstance(arg_list,unicode):

outlist.append(arg_list.encode('utf-8'))

elifnotPY3andisinstance(arg_list,unicode):

outlist.append(arg_list.encode(defenc))

else:

outlist.append(str(arg))

opt_args=self.transform_kwargs(**kwargs)

ext_args=self.__unpack_args([aforainargsifaisnotNone])

defmake_call():

raiseValueError("Failed to parse header: %r"%header_line)

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

def__prepare_ref(self,ref):

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

ifrefstr.endswith("\n"):

def_prepare_ref(self,ref):

ifisinstance(ref,bytes):

refstr=ref.decode('ascii')

elifnotisinstance(ref,string_types):

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

ifnotrefstr.endswith("\n"):

returnrefstr.encode(defenc)

def__get_persistent_cmd(self,attr_name,cmd_name,*args,**kwargs):

def_get_persistent_cmd(self,attr_name,cmd_name,*args,**kwargs):

cur_val=getattr(self,attr_name)

ifcur_valisnotNone:

def__get_object_header(self,cmd,ref):

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

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

cmd.stdin.flush()

returnself._parse_object_header(cmd.stdout.readline())

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

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

returnself.__get_object_header(cmd,ref)

defget_object_data(self,ref):

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

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))

fromgitdb.utils.compatimport (

PY3,

xrange,

MAXSIZE,

izip,

)

fromgitdb.utils.encodingimport (

string_types,

text_type,

force_bytes,

)

defenc=sys.getdefaultencoding()

ifPY3:

FileType=io.IOBase

defbyte_ord(b):

defbchr(n):

returnbytes([n])

defmviter(d):

returnd.values()

else:

ifdefenc=='ascii':

defmviter(d):

returnd.itervalues()

defwith_metaclass(meta,*bases):

classmetaclass(meta):

__call__=type.__call__

__init__=type.__init__

def__new__(cls,name,nbases,d):

ifnbasesisNone:

returntype.__new__(cls,name, (),d)

ifnotPY3and'___metaclass__'notind:

d['__metaclass__']=meta

returnmeta(name,bases,d)

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