/brz/remove-bazaar

from __future__ import absolute_import

 

from .sixish import (

    PY3,

    text_type,

    )

 

# Cross platform wall-clock time functionality with decent resolution.

# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``

# only has a resolution of ~15ms. Note that ``time.clock()`` is not

# synchronized with ``time.time()``, this is only meant to be used to find

# delta times by subtracting from another call to this function.

timer_func = time.time

if sys.platform == 'win32':

    timer_func = time.clock

 

def get_unicode_argv():

    if PY3:

        return sys.argv[1:]

    try:

        user_encoding = get_user_encoding()

        return [a.decode(user_encoding) for a in sys.argv[1:]]

    except UnicodeDecodeError:

        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "

            "application locale.").format(a, user_encoding))

 

 

        return path.split('/')

                return False;

                raise errors.BzrError(gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))

    except (errors.NoSuchFile,) as e:

            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):

            and old.lower() == new.lower()):

    # the repo is hosted at the root of the filesystem, i.e. in "/".    

def _posix_path_from_environ(key):

    """Get unicode path from `key` in environment or None if not present

 

    Note that posix systems use arbitrary byte strings for filesystem objects,

    so a path that raises BadFilenameEncoding here may still be accessible.

    """

    val = os.environ.get(key, None)

    if PY3 or val is None:

        return val

    try:

        return val.decode(_fs_enc)

    except UnicodeDecodeError:

        # GZ 2011-12-12:Ideally want to include `key` in the exception message

        raise errors.BadFilenameEncoding(val, _fs_enc)

 

 

    name = getpass.getuser()

    if PY3:

        return name

    user_encoding = get_user_encoding()

    try:

        return name.decode(user_encoding)

    except UnicodeDecodeError:

        raise errors.BzrError("Encoding of username %r is unsupported by %s "

            "application locale." % (name, user_encoding))

    return _win32_fixdrive(ntpath.abspath(unicode(path)).replace('\\', '/'))

    return _win32_fixdrive(ntpath.realpath(unicode(path)).replace('\\', '/'))

    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))

                                " [occurred when renaming '%s' to '%s']" %

                                (old, new))

if sys.version_info > (3,):

    _getcwd = os.getcwd

else:

    _getcwd = os.getcwdu

path_from_environ = _posix_path_from_environ

            and isinstance(exception, OSError) \

            and exception.errno == errno.EACCES:

    f = win32utils.get_unicode_argv     # special function or None

    if f is not None:

        get_unicode_argv = f

    path_from_environ = win32utils.get_environ_unicode

                   output_encoding)

                    output_encoding)

               ' encoding stdout as osutils.get_user_encoding() %r',

               output_encoding)

                        )

    if dir == '':

    if dir[-1] != '/':

        dir += '/'

        segment_size = 5242880 # 5MB

        write(view[offset:offset+segment_size])

if PY3:

    def _hexdigest(hashobj):

        return hashobj.hexdigest().encode()

else:

    def _hexdigest(hashobj):

        return hashobj.hexdigest()

    BUFSIZE = 128<<10

    BUFSIZE = 128<<10

            b = os.read(f, 1<<16)

        if ai == '':

               _format_date(t, offset, timezone, date_fmt, show_offset)

    _cache=_offset_cache):

               _format_date(t, offset, timezone, date_fmt, show_offset)

    if not isinstance(date_str, text_type):

    if seconds < 90: # print seconds up to 90 seconds

    if minutes < 90: # print minutes, seconds up to 90 minutes

                    minutes, seconds, plural_seconds, direction)

                    minutes, seconds, plural_seconds, direction)

# Alias os.urandom to support platforms (which?) without /dev/urandom and 

        if not PY3:

            s += ALNUM[ord(raw_byte) % 36]

        else:

            s += ALNUM[raw_byte % 36]

## TODO: We could later have path objects that remember their list

## decomposition (might be too tricksy though.)

    # split on either delimiter because people might use either on

    # Windows

    ps = re.split(r'[\\/]', p)

        if f == '..':

        elif (f == '.') or (f == ''):

    if isinstance(s, str):

       _delete_file_or_dir(path)

    if isdir(path): # Takes care of symlinks

            % (base,))

    _listdir = os.listdir

            next_entries = _listdir(current)

        except OSError: # enoent, eperm, etc

        for look in next_entries:

            if lbit == look.lower():

                current = pathjoin(current, look)

    if isinstance(filename, text_type):

    if isinstance(unicode_or_utf8_string, text_type):

def safe_revision_id(unicode_or_utf8_string):

    """Revision ids should now be utf8, but at one point they were unicode.

 

    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be

        utf8 or None).

    :return: None or a utf8 revision id.

    """

    if (unicode_or_utf8_string is None

        or unicode_or_utf8_string.__class__ == bytes):

        return unicode_or_utf8_string

    raise TypeError('Unicode revision ids are no longer supported. '

                    'Revision id generators should be creating utf8 revision '

                    'ids.')

 

 

def safe_file_id(unicode_or_utf8_string):

    """File ids should now be utf8, but at one point they were unicode.

 

    This is the same as safe_utf8, except it uses the cached encode functions

    to save a little bit of performance.

 

    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be

        utf8 or None).

    :return: None or a utf8 file id.

    """

    if (unicode_or_utf8_string is None

        or unicode_or_utf8_string.__class__ == bytes):

        return unicode_or_utf8_string

    raise TypeError('Unicode file ids are no longer supported. '

                    'File id generators should be creating utf8 file ids.')

 

 

    return unicodedata.normalize('NFC', text_type(path)), True

    normalized = unicodedata.normalize('NFC', text_type(path))

        siginterrupt = lambda signum, flag: None

    width, height = win32utils.get_console_size(defaultx=width, defaulty=height)

        import struct, fcntl, termios

def supports_executable():

    return sys.platform != "win32"

        if not PY3 and isinstance(value, text_type):

            value = value.encode(get_user_encoding())

_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR

    if (en == errno.ENOTDIR

        or (sys.platform == 'win32'

            and (en == _WIN32_ERROR_DIRECTORY

                 or (en == errno.EINVAL

                     and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)

        ))):

    #TODO there is a bit of a smell where the results of the directory-

    _lstat = os.lstat

    _listdir = os.listdir

    _kind_from_mode = file_kind_from_stat_mode

        append = dirblock.append

            names = sorted(map(decode_filename, _listdir(top)))

        else:

            for name in names:

                abspath = top_slash + name

                statvalue = _lstat(abspath)

                kind = _kind_from_mode(statvalue.st_mode)

                append((relprefix + name, name, kind, statvalue, abspath))