try:

size = __calcsize_cache[fmt]

except KeyError:

size = calcsize(fmt)

__calcsize_cache[fmt] = size

# END exception handling

"""Wrapper to provide required functionality in case memory maps cannot or may

__slots__ = '_sio'

def __init__(self, buf=''):

self._sio = StringIO(buf)

def __getattr__(self, attr):

return getattr(self._sio, attr)

def __len__(self):

return len(self.getvalue())

def __getitem__(self, i):

return self.getvalue()[i]

def __getslice__(self, start, end):

""":return: string identifying the currently active system user as name@node

if os.name == "posix":

username = pwd.getpwuid(os.geteuid()).pw_name

else:

ukn = 'UNKNOWN'

username = os.environ.get('USER', os.environ.get('USERNAME', ukn))

if username == ukn and hasattr(os, 'getlogin'):

username = os.getlogin()

# END get username from login

""" This is taken from the git setup.c:is_git_directory

if isdir(d) and \

isdir(join(d, 'objects')) and \

isdir(join(d, 'refs')):

headref = join(d, 'HEAD')

return isfile(headref) or \

(os.path.islink(headref) and

os.readlink(headref).startswith('refs'))

"""Remove the given recursively.

def onerror(func, path, exc_info):

if not os.access(path, os.W_OK):

# Is the error an access error ?

os.chmod(path, stat.S_IWUSR)

func(path)

else:

raise

# END end onerror

"""Copy all data from the source stream into the destination stream in chunks

br = 0

while True:

chunk = source.read(chunk_size)

destination.write(chunk)

br += len(chunk)

if len(chunk) < chunk_size:

break

# END reading output stream

"""A python2.4 workaround for the sha/hashlib module fiasco

try:

return hashlib.sha1(source)

except NameError:

sha1 = sha.sha(source)

""":return: a file-protocol accessible memory block of the given size"""

if size == 0:

return _RandomAccessStringIO('')

# END handle empty chunks gracefully

try:

return mmap.mmap(-1, size) # read-write by default

except EnvironmentError:

# setup real memory instead

# this of course may fail if the amount of memory is not available in

# one chunk - would only be the case in python 2.4, being more likely on

# 32 bit systems.

return _RandomAccessStringIO("\0" * size)

""":return: read-only contents of the file represented by the file descriptor fd

try:

if allow_mmap:

# supports stream and random access

try:

return mmap.mmap(fd, 0, access=mmap.ACCESS_READ)

except EnvironmentError:

# python 2.4 issue, 0 wants to be the actual size

return mmap.mmap(fd, os.fstat(fd).st_size, access=mmap.ACCESS_READ)

# END handle python 2.4

except OSError:

pass

# END exception handling

# read manully

contents = os.read(fd, os.fstat(fd).st_size)

if stream:

return _RandomAccessStringIO(contents)

"""Get the file contents at filepath as fast as possible

fd = os.open(filepath, os.O_RDONLY | getattr(os, 'O_BINARY', 0) | flags)

try:

return file_contents_ro(fd, stream, allow_mmap)

finally:

close(fd)

""":return: hexified version of sha"""

if len(sha) == 40:

return sha

"""Join path tokens together similar to os.path.join, but always use

path = a

for b in p:

if len(b) == 0:

continue

if b.startswith('/'):

path += b[1:]

elif path == '' or path.endswith('/'):

path += b

else:

path += '/' + b

# END for each path token to add

"""

"""Assure that the directory pointed to by path exists.

if is_file:

path = os.path.dirname(path)

# END handle file

if not os.path.isdir(path):

os.makedirs(path)

return True

"""

__slots__ = tuple()

def __getattr__(self, attr):

"""

self._set_cache_(attr)

# will raise in case the cache was not created

return object.__getattribute__(self, attr)

def _set_cache_(self, attr):

"""

"""

__slots__ = ("_filepath", '_fd', '_write')

def __init__(self, filepath):

"""Initialize an instance with the givne filepath"""

self._filepath = filepath

self._fd = None

self._write = None # if True, we write a file

def __del__(self):

# will do nothing if the file descriptor is already closed

if self._fd is not None:

self.rollback()

def _lockfilepath(self):

return "%s.lock" % self._filepath

def open(self, write=False, stream=False):

"""

if self._write is not None:

raise AssertionError("Called %s multiple times" % self.open)

self._write = write

# try to open the lock file

binary = getattr(os, 'O_BINARY', 0)

lockmode = os.O_WRONLY | os.O_CREAT | os.O_EXCL | binary

try:

fd = os.open(self._lockfilepath(), lockmode, 0600)

if not write:

os.close(fd)

else:

self._fd = fd

# END handle file descriptor

except OSError:

raise IOError("Lock at %r could not be obtained" % self._lockfilepath())

# END handle lock retrieval

# open actual file if required

if self._fd is None:

# we could specify exlusive here, as we obtained the lock anyway

try:

self._fd = os.open(self._filepath, os.O_RDONLY | binary)

except:

# assure we release our lockfile

os.remove(self._lockfilepath())

raise

# END handle lockfile

# END open descriptor for reading

if stream:

# need delayed import

from stream import FDStream

return FDStream(self._fd)

else:

return self._fd

# END handle stream

def commit(self):

"""When done writing, call this function to commit your changes into the

self._end_writing(successful=True)

def rollback(self):

"""Abort your operation without any changes. The file descriptor will be

self._end_writing(successful=False)

def _end_writing(self, successful=True):

"""Handle the lock according to the write mode """

if self._write is None:

raise AssertionError("Cannot end operation if it wasn't started yet")

if self._fd is None:

return

os.close(self._fd)

self._fd = None

lockfile = self._lockfilepath()

if self._write and successful:

# on windows, rename does not silently overwrite the existing one

if sys.platform == "win32":

if isfile(self._filepath):

os.remove(self._filepath)

# END remove if exists

# END win32 special handling

os.rename(lockfile, self._filepath)

# assure others can at least read the file - the tmpfile left it at rw--

# We may also write that file, on windows that boils down to a remove-

# protection as well

chmod(self._filepath, 0644)

else:

# just delete the file so far, we failed

os.remove(lockfile)

"""Provides methods to obtain, check for, and release a file based lock which

__slots__ = ("_file_path", "_owns_lock")

def __init__(self, file_path):

self._file_path = file_path

self._owns_lock = False

def __del__(self):

self._release_lock()

def _lock_file_path(self):

""":return: Path to lockfile"""

return "%s.lock" % (self._file_path)

def _has_lock(self):

""":return: True if we have a lock and if the lockfile still exists

if not self._owns_lock:

return False

return True

def _obtain_lock_or_raise(self):

"""Create a lock file as flag for other instances, mark our instance as lock-holder

if self._has_lock():

return

lock_file = self._lock_file_path()

if os.path.isfile(lock_file):

raise IOError("Lock for file %r did already exist, delete %r in case the lock is illegal" %

(self._file_path, lock_file))

try:

fd = os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0)

os.close(fd)

except OSError, e:

raise IOError(str(e))

self._owns_lock = True

def _obtain_lock(self):

"""The default implementation will raise if a lock cannot be obtained.

return self._obtain_lock_or_raise()

def _release_lock(self):

"""Release our lock if we have one"""

if not self._has_lock():

return

# if someone removed our file beforhand, lets just flag this issue

# instead of failing, to make it more usable.

lfp = self._lock_file_path()

try:

# on bloody windows, the file needs write permissions to be removable.

# Why ...

if os.name == 'nt':

os.chmod(lfp, 0777)

# END handle win32

os.remove(lfp)

except OSError:

pass

"""The lock file will block until a lock could be obtained, or fail after

__slots__ = ("_check_interval", "_max_block_time")

def __init__(self, file_path, check_interval_s=0.3, max_block_time_s=sys.maxint):

"""Configure the instance

super(BlockingLockFile, self).__init__(file_path)

self._check_interval = check_interval_s

self._max_block_time = max_block_time_s

def _obtain_lock(self):

"""This method blocks until it obtained the lock, or raises IOError if

starttime = time.time()

maxtime = starttime + float(self._max_block_time)

while True:

try:

super(BlockingLockFile, self)._obtain_lock()

except IOError:

# synity check: if the directory leading to the lockfile is not

# readable anymore, raise an execption

curtime = time.time()

if not os.path.isdir(os.path.dirname(self._lock_file_path())):

msg = "Directory containing the lockfile %r was not readable anymore after waiting %g seconds" % (

self._lock_file_path(), curtime - starttime)

raise IOError(msg)

# END handle missing directory

if curtime >= maxtime:

msg = "Waited %g seconds for lock at %r" % (maxtime - starttime, self._lock_file_path())

raise IOError(msg)

# END abort if we wait too long

time.sleep(self._check_interval)

else:

break

"""Actors hold information about a person acting on the repository. They

# PRECOMPILED REGEX

name_only_regex = re.compile(r'<(.+)>')

name_email_regex = re.compile(r'(.*) <(.+?)>')

# ENVIRONMENT VARIABLES

# read when creating new commits

env_author_name = "GIT_AUTHOR_NAME"

env_author_email = "GIT_AUTHOR_EMAIL"

env_committer_name = "GIT_COMMITTER_NAME"

env_committer_email = "GIT_COMMITTER_EMAIL"

# CONFIGURATION KEYS

conf_name = 'name'

conf_email = 'email'

__slots__ = ('name', 'email')

def __init__(self, name, email):

self.name = name

self.email = email

def __eq__(self, other):

return self.name == other.name and self.email == other.email

def __ne__(self, other):

return not (self == other)

def __hash__(self):

return hash((self.name, self.email))

def __str__(self):

return self.name

def __repr__(self):

return '<git.Actor "%s <%s>">' % (self.name, self.email)

@classmethod

def _from_string(cls, string):

"""Create an Actor from a string.

m = cls.name_email_regex.search(string)

if m:

name, email = m.groups()

return cls(name, email)

else:

m = cls.name_only_regex.search(string)

if m:

return cls(m.group(1), None)

else:

# assume best and use the whole string as name

return cls(string, None)

# END special case name

# END handle name/email matching

@classmethod

def _main_actor(cls, env_name, env_email, config_reader=None):

actor = cls('', '')

default_email = get_user_id()

default_name = default_email.split('@')[0]

for attr, evar, cvar, default in (('name', env_name, cls.conf_name, default_name),

('email', env_email, cls.conf_email, default_email)):

try:

setattr(actor, attr, os.environ[evar])

except KeyError:

if config_reader is not None:

setattr(actor, attr, config_reader.get_value('user', cvar, default))

# END config-reader handling

if not getattr(actor, attr):

setattr(actor, attr, default)

# END handle name

# END for each item to retrieve

return actor

@classmethod

def committer(cls, config_reader=None):

"""

return cls._main_actor(cls.env_committer_name, cls.env_committer_email, config_reader)

@classmethod

def author(cls, config_reader=None):

"""Same as committer(), but defines the main author. It may be specified in the environment,

"""Defines an interface for iterable items which is to assure a uniform

__slots__ = tuple()

_id_attribute_ = "attribute that most suitably identifies your instance"

@classmethod

def list_items(cls, repo, *args, **kwargs):

"""

out_list = IterableList(cls._id_attribute_)

out_list.extend(cls.iter_items(repo, *args, **kwargs))

return out_list

@classmethod

def iter_items(cls, repo, *args, **kwargs):

"""For more information about the arguments, see list_items

"""

__slots__ = ('_id_attr', '_prefix')

def __new__(cls, id_attr, prefix=''):

return super(IterableList, cls).__new__(cls)

def __init__(self, id_attr, prefix=''):

self._id_attr = id_attr

self._prefix = prefix

if not isinstance(id_attr, basestring):

raise ValueError(

"First parameter must be a string identifying the name-property. Extend the list after initialization")

# END help debugging !

def __contains__(self, attr):

# first try identy match for performance

rval = list.__contains__(self, attr)

if rval:

return rval

# END handle match

# otherwise make a full name search

try:

getattr(self, attr)

return True

except (AttributeError, TypeError):

return False

# END handle membership

def __getattr__(self, attr):

attr = self._prefix + attr

for item in self:

if getattr(item, self._id_attr) == attr:

return item

# END for each item

return list.__getattribute__(self, attr)

def __getitem__(self, index):

if isinstance(index, int):

return list.__getitem__(self, index)

try:

return getattr(self, index)

except AttributeError:

raise IndexError("No item found with id %r" % (self._prefix + index))

# END handle getattr

def __delitem__(self, index):

delindex = index

if not isinstance(index, int):

delindex = -1

name = self._prefix + index

for i, item in enumerate(self):

if getattr(item, self._id_attr) == name:

delindex = i

break

# END search index

# END for each item

if delindex == -1:

raise IndexError("Item with name %s not found" % name)

# END handle error

# END get index to delete

"""Simple utility providing a repo-property which resolves to the 'odb' attribute

__slots__ = tuple()

@property

def repo(self):

"""

__slots__ = ("total", "files")

def __init__(self, total, files):

self.total = total

self.files = files

@classmethod

def _list_from_string(cls, repo, text):

"""Create a Stat object from output retrieved by git-diff.

hsh = {'total': {'insertions': 0, 'deletions': 0, 'lines': 0, 'files': 0}, 'files': dict()}

for line in text.splitlines():

(raw_insertions, raw_deletions, filename) = line.split("\t")

insertions = raw_insertions != '-' and int(raw_insertions) or 0

deletions = raw_deletions != '-' and int(raw_deletions) or 0

hsh['total']['insertions'] += insertions

hsh['total']['deletions'] += deletions

hsh['total']['lines'] += insertions + deletions

hsh['total']['files'] += 1

hsh['files'][filename.strip()] = {'insertions': insertions,

'deletions': deletions,

'lines': insertions + deletions}

"""Wrapper around a file-like object that remembers the SHA1 of

__slots__ = ("f", "sha1")

def __init__(self, f):

self.f = f

self.sha1 = make_sha("")

def write(self, data):

self.sha1.update(data)

return self.f.write(data)

def write_sha(self):

sha = self.sha1.digest()

self.f.write(sha)

return sha

def close(self):

sha = self.write_sha()

self.f.close()

return sha

def tell(self):