/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/urlutils.py

Merge test-run support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/urlutils.py
38
38
""")
39
39
 
40
40
from .sixish import (
41
 
    int2byte,
42
41
    PY3,
43
42
    text_type,
44
 
    unichr,
45
43
    )
46
44
 
47
45
 
68
66
    def __init__(self, from_, to):
69
67
        self.from_ = from_
70
68
        self.to = to
71
 
        errors.PathError.__init__(
72
 
            self, from_, 'URLs differ by more than path.')
 
69
        errors.PathError.__init__(self, from_, 'URLs differ by more than path.')
73
70
 
74
71
 
75
72
def basename(url, exclude_trailing_slash=True):
99
96
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
100
97
 
101
98
 
102
 
if PY3:
103
 
    quote_from_bytes = urlparse.quote_from_bytes
104
 
    quote = urlparse.quote
105
 
    unquote_to_bytes = urlparse.unquote_to_bytes
106
 
else:
107
 
    # Private copies of quote and unquote, copied from Python's urllib module
108
 
    # because urllib unconditionally imports socket, which imports ssl.
109
 
 
110
 
    always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
111
 
                   'abcdefghijklmnopqrstuvwxyz'
112
 
                   '0123456789' '_.-')
113
 
    _safe_map = {}
114
 
    for i, c in zip(range(256), ''.join(map(chr, range(256)))):
115
 
        _safe_map[c] = c if (
116
 
            i < 128 and c in always_safe) else '%{0:02X}'.format(i)
117
 
    _safe_quoters = {}
118
 
 
119
 
    def quote_from_bytes(s, safe='/'):
120
 
        """quote('abc def') -> 'abc%20def'
121
 
 
122
 
        Each part of a URL, e.g. the path info, the query, etc., has a
123
 
        different set of reserved characters that must be quoted.
124
 
 
125
 
        RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
126
 
        the following reserved characters.
127
 
 
128
 
        reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
129
 
                      "$" | ","
130
 
 
131
 
        Each of these characters is reserved in some component of a URL,
132
 
        but not necessarily in all of them.
133
 
 
134
 
        By default, the quote function is intended for quoting the path
135
 
        section of a URL.  Thus, it will not encode '/'.  This character
136
 
        is reserved, but in typical usage the quote function is being
137
 
        called on a path where the existing slash characters are used as
138
 
        reserved characters.
139
 
        """
140
 
        # fastpath
141
 
        if not s:
142
 
            if s is None:
143
 
                raise TypeError('None object cannot be quoted')
144
 
            return s
145
 
        cachekey = (safe, always_safe)
146
 
        try:
147
 
            (quoter, safe) = _safe_quoters[cachekey]
148
 
        except KeyError:
149
 
            safe_map = _safe_map.copy()
150
 
            safe_map.update([(c, c) for c in safe])
151
 
            quoter = safe_map.__getitem__
152
 
            safe = always_safe + safe
153
 
            _safe_quoters[cachekey] = (quoter, safe)
154
 
        if not s.rstrip(safe):
155
 
            return s
156
 
        return ''.join(map(quoter, s))
157
 
 
158
 
    quote = quote_from_bytes
159
 
    unquote_to_bytes = urlparse.unquote
 
99
# Private copies of quote and unquote, copied from Python's
 
100
# urllib module because urllib unconditionally imports socket, which imports
 
101
# ssl.
 
102
 
 
103
always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
104
               'abcdefghijklmnopqrstuvwxyz'
 
105
               '0123456789' '_.-')
 
106
_safe_map = {}
 
107
for i, c in zip(range(256), ''.join(map(chr, range(256)))):
 
108
    _safe_map[c] = c if (i < 128 and c in always_safe) else '%{0:02X}'.format(i)
 
109
_safe_quoters = {}
 
110
 
 
111
 
 
112
def quote(s, safe='/'):
 
113
    """quote('abc def') -> 'abc%20def'
 
114
 
 
115
    Each part of a URL, e.g. the path info, the query, etc., has a
 
116
    different set of reserved characters that must be quoted.
 
117
 
 
118
    RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
 
119
    the following reserved characters.
 
120
 
 
121
    reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
 
122
                  "$" | ","
 
123
 
 
124
    Each of these characters is reserved in some component of a URL,
 
125
    but not necessarily in all of them.
 
126
 
 
127
    By default, the quote function is intended for quoting the path
 
128
    section of a URL.  Thus, it will not encode '/'.  This character
 
129
    is reserved, but in typical usage the quote function is being
 
130
    called on a path where the existing slash characters are used as
 
131
    reserved characters.
 
132
    """
 
133
    # fastpath
 
134
    if not s:
 
135
        if s is None:
 
136
            raise TypeError('None object cannot be quoted')
 
137
        return s
 
138
    cachekey = (safe, always_safe)
 
139
    try:
 
140
        (quoter, safe) = _safe_quoters[cachekey]
 
141
    except KeyError:
 
142
        safe_map = _safe_map.copy()
 
143
        safe_map.update([(c, c) for c in safe])
 
144
        quoter = safe_map.__getitem__
 
145
        safe = always_safe + safe
 
146
        _safe_quoters[cachekey] = (quoter, safe)
 
147
    if not s.rstrip(safe):
 
148
        return s
 
149
    return ''.join(map(quoter, s))
160
150
 
161
151
 
162
152
unquote = urlparse.unquote
163
153
 
164
154
 
165
 
def escape(relpath, safe='/~'):
 
155
def escape(relpath):
166
156
    """Escape relpath to be a valid url."""
167
157
    if not isinstance(relpath, str) and sys.version_info[0] == 2:
168
 
        # GZ 2019-06-16: Should use _fs_enc instead here really?
169
158
        relpath = relpath.encode('utf-8')
170
 
    return quote(relpath, safe=safe)
 
159
    return quote(relpath, safe='/~')
171
160
 
172
161
 
173
162
def file_relpath(base, path):
177
166
    """
178
167
    if len(base) < MIN_ABS_FILEURL_LENGTH:
179
168
        raise ValueError('Length of base (%r) must equal or'
180
 
                         ' exceed the platform minimum url length (which is %d)' %
181
 
                         (base, MIN_ABS_FILEURL_LENGTH))
 
169
            ' exceed the platform minimum url length (which is %d)' %
 
170
            (base, MIN_ABS_FILEURL_LENGTH))
182
171
    base = osutils.normpath(local_path_from_url(base))
183
172
    path = osutils.normpath(local_path_from_url(path))
184
173
    return escape(osutils.relpath(base, path))
202
191
    first_path_slash = path.find('/')
203
192
    if first_path_slash == -1:
204
193
        return len(scheme), None
205
 
    return len(scheme), first_path_slash + m.start('path')
 
194
    return len(scheme), first_path_slash+m.start('path')
206
195
 
207
196
 
208
197
def is_url(url):
258
247
    """
259
248
    path = base.split('/')
260
249
    if len(path) > 1 and path[-1] == '':
261
 
        # If the path ends in a trailing /, remove it.
 
250
        #If the path ends in a trailing /, remove it.
262
251
        path.pop()
263
252
    for arg in args:
264
253
        if arg.startswith('/'):
269
258
            elif chunk == '..':
270
259
                if path == ['']:
271
260
                    raise InvalidURLJoin('Cannot go above root',
272
 
                                         base, args)
 
261
                            base, args)
273
262
                path.pop()
274
263
            else:
275
264
                path.append(chunk)
282
271
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
283
272
def _posix_local_path_from_url(url):
284
273
    """Convert a url like file:///path/to/foo into /path/to/foo"""
285
 
    url = strip_segment_parameters(url)
 
274
    url = split_segment_parameters_raw(url)[0]
286
275
    file_localhost_prefix = 'file://localhost/'
287
276
    if url.startswith(file_localhost_prefix):
288
277
        path = url[len(file_localhost_prefix) - 1:]
309
298
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
310
299
    if not url.startswith('file://'):
311
300
        raise InvalidURL(url, 'local urls must start with file:///, '
312
 
                         'UNC path urls must start with file://')
313
 
    url = strip_segment_parameters(url)
 
301
                                     'UNC path urls must start with file://')
 
302
    url = split_segment_parameters_raw(url)[0]
314
303
    # We strip off all 3 slashes
315
304
    win32_url = url[len('file:'):]
316
305
    # check for UNC path: //HOST/path
317
306
    if not win32_url.startswith('///'):
318
307
        if (win32_url[2] == '/'
319
 
                or win32_url[3] in '|:'):
 
308
            or win32_url[3] in '|:'):
320
309
            raise InvalidURL(url, 'Win32 UNC path urls'
321
 
                             ' have form file://HOST/path')
 
310
                ' have form file://HOST/path')
322
311
        return unescape(win32_url)
323
312
 
324
313
    # allow empty paths so we can serve all roots
328
317
    # usual local path with drive letter
329
318
    if (len(win32_url) < 6
330
319
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
331
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ') or
332
 
        win32_url[4] not in '|:'
333
 
            or win32_url[5] != '/'):
 
320
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
321
        or win32_url[4] not in  '|:'
 
322
        or win32_url[5] != '/'):
334
323
        raise InvalidURL(url, 'Win32 file urls start with'
335
 
                         ' file:///x:/, where x is a valid drive letter')
 
324
                ' file:///x:/, where x is a valid drive letter')
336
325
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
337
326
 
338
327
 
355
344
    if win32_path.startswith('//'):
356
345
        return 'file:' + escape(win32_path)
357
346
    return ('file:///' + str(win32_path[0].upper()) + ':' +
358
 
            escape(win32_path[2:]))
 
347
        escape(win32_path[2:]))
359
348
 
360
349
 
361
350
local_path_to_url = _posix_local_path_to_url
415
404
        for c in url:
416
405
            if c not in _url_safe_characters:
417
406
                raise InvalidURL(url, 'URLs can only contain specific'
418
 
                                 ' safe characters (not %r)' % c)
 
407
                                            ' safe characters (not %r)' % c)
419
408
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
420
409
        return str(prefix + ''.join(path))
421
410
 
424
413
 
425
414
    for i in range(len(path_chars)):
426
415
        if path_chars[i] not in _url_safe_characters:
 
416
            chars = path_chars[i].encode('utf-8')
427
417
            path_chars[i] = ''.join(
428
 
                ['%%%02X' % c for c in bytearray(path_chars[i].encode('utf-8'))])
 
418
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
429
419
    path = ''.join(path_chars)
430
420
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
431
421
    return str(prefix + path)
451
441
    if base_scheme != other_scheme:
452
442
        return other
453
443
    elif sys.platform == 'win32' and base_scheme == 'file://':
454
 
        base_drive = base[base_first_slash + 1:base_first_slash + 3]
455
 
        other_drive = other[other_first_slash + 1:other_first_slash + 3]
 
444
        base_drive = base[base_first_slash+1:base_first_slash+3]
 
445
        other_drive = other[other_first_slash+1:other_first_slash+3]
456
446
        if base_drive != other_drive:
457
447
            return other
458
448
 
459
 
    base_path = base[base_first_slash + 1:]
460
 
    other_path = other[other_first_slash + 1:]
 
449
    base_path = base[base_first_slash+1:]
 
450
    other_path = other[other_first_slash+1:]
461
451
 
462
452
    if base_path.endswith('/'):
463
453
        base_path = base_path[:-1]
489
479
    # path is currently /C:/foo
490
480
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
491
481
        raise InvalidURL(url_base + path,
492
 
                         'win32 file:/// paths need a drive letter')
493
 
    url_base += path[0:3]  # file:// + /C:
494
 
    path = path[3:]  # /foo
 
482
            'win32 file:/// paths need a drive letter')
 
483
    url_base += path[0:3] # file:// + /C:
 
484
    path = path[3:] # /foo
495
485
    return url_base, path
496
486
 
497
487
 
502
492
    :param exclude_trailing_slash: Strip off a final '/' if it is part
503
493
        of the path (but not if it is part of the protocol specification)
504
494
 
505
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if
506
 
        we're at the root.
 
495
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
 
496
        the root.
507
497
    """
508
498
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
509
499
 
519
509
            return url, ''
520
510
 
521
511
    # We have a fully defined path
522
 
    url_base = url[:first_path_slash]  # http://host, file://
523
 
    path = url[first_path_slash:]  # /file/foo
 
512
    url_base = url[:first_path_slash] # http://host, file://
 
513
    path = url[first_path_slash:] # /file/foo
524
514
 
525
515
    if sys.platform == 'win32' and url.startswith('file:///'):
526
516
        # Strip off the drive letter
543
533
    """
544
534
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
545
535
    #                operates on urls not url+segments, and Transport classes
546
 
    #                should not be blindly adding slashes in the first place.
 
536
    #                should not be blindly adding slashes in the first place. 
547
537
    lurl = strip_trailing_slash(url)
548
538
    # Segments begin at first comma after last forward slash, if one exists
549
 
    segment_start = lurl.find(",", lurl.rfind("/") + 1)
 
539
    segment_start = lurl.find(",", lurl.rfind("/")+1)
550
540
    if segment_start == -1:
551
541
        return (url, [])
552
 
    return (lurl[:segment_start],
553
 
            [str(s) for s in lurl[segment_start + 1:].split(",")])
 
542
    return (lurl[:segment_start], [str(s) for s in lurl[segment_start+1:].split(",")])
554
543
 
555
544
 
556
545
def split_segment_parameters(url):
562
551
    (base_url, subsegments) = split_segment_parameters_raw(url)
563
552
    parameters = {}
564
553
    for subsegment in subsegments:
565
 
        try:
566
 
            (key, value) = subsegment.split("=", 1)
567
 
        except ValueError:
568
 
            raise InvalidURL(url, "missing = in subsegment")
 
554
        (key, value) = subsegment.split("=", 1)
569
555
        if not isinstance(key, str):
570
556
            raise TypeError(key)
571
557
        if not isinstance(value, str):
574
560
    return (base_url, parameters)
575
561
 
576
562
 
577
 
def strip_segment_parameters(url):
578
 
    """Strip the segment parameters from a URL.
579
 
 
580
 
    :param url: A relative or absolute URL
581
 
    :return: url
582
 
    """
583
 
    base_url, subsegments = split_segment_parameters_raw(url)
584
 
    return base_url
585
 
 
586
 
 
587
563
def join_segment_parameters_raw(base, *subsegments):
588
 
    """Create a new URL by adding subsegments to an existing one.
 
564
    """Create a new URL by adding subsegments to an existing one. 
589
565
 
590
566
    This adds the specified subsegments to the last path in the specified
591
567
    base URL. The subsegments should be bytestrings.
599
575
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
600
576
        if "," in subsegment:
601
577
            raise InvalidURLJoin(", exists in subsegments",
602
 
                                 base, subsegments)
 
578
                                        base, subsegments)
603
579
    return ",".join((base,) + subsegments)
604
580
 
605
581
 
619
595
        if not isinstance(key, str):
620
596
            raise TypeError("parameter key %r is not a str" % key)
621
597
        if not isinstance(value, str):
622
 
            raise TypeError("parameter value %r for %r is not a str" %
623
 
                            (value, key))
 
598
            raise TypeError("parameter value %r for %s is not a str" %
 
599
                (key, value))
624
600
        if "=" in key:
625
601
            raise InvalidURLJoin("= exists in parameter key", url,
626
 
                                 parameters)
 
602
                parameters)
627
603
        new_parameters[key] = value
628
 
    return join_segment_parameters_raw(
629
 
        base, *["%s=%s" % item for item in sorted(new_parameters.items())])
 
604
    return join_segment_parameters_raw(base,
 
605
        *["%s=%s" % item for item in sorted(new_parameters.items())])
630
606
 
631
607
 
632
608
def _win32_strip_local_trailing_slash(url):
670
646
        # so just chop off the last character
671
647
        return url[:-1]
672
648
 
673
 
    if first_path_slash is None or first_path_slash == len(url) - 1:
 
649
    if first_path_slash is None or first_path_slash == len(url)-1:
674
650
        # Don't chop off anything if the only slash is the path
675
651
        # separating slash
676
652
        return url
690
666
    #       plain ASCII strings, or the final .decode will
691
667
    #       try to encode the UNICODE => ASCII, and then decode
692
668
    #       it into utf-8.
693
 
 
 
669
    if isinstance(url, text_type):
 
670
        try:
 
671
            url = url.encode("ascii")
 
672
        except UnicodeError as e:
 
673
            raise InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
694
674
    if PY3:
695
 
        if isinstance(url, text_type):
696
 
            try:
697
 
                url.encode("ascii")
698
 
            except UnicodeError as e:
699
 
                raise InvalidURL(
700
 
                    url, 'URL was not a plain ASCII url: %s' % (e,))
701
 
        return urlparse.unquote(url)
 
675
        unquoted = urlparse.unquote_to_bytes(url)
702
676
    else:
703
 
        if isinstance(url, text_type):
704
 
            try:
705
 
                url = url.encode("ascii")
706
 
            except UnicodeError as e:
707
 
                raise InvalidURL(
708
 
                    url, 'URL was not a plain ASCII url: %s' % (e,))
709
677
        unquoted = unquote(url)
710
 
        try:
711
 
            unicode_path = unquoted.decode('utf-8')
712
 
        except UnicodeError as e:
713
 
            raise InvalidURL(
714
 
                url, 'Unable to encode the URL as utf-8: %s' % (e,))
715
 
        return unicode_path
 
678
    try:
 
679
        unicode_path = unquoted.decode('utf-8')
 
680
    except UnicodeError as e:
 
681
        raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
682
    return unicode_path
716
683
 
717
684
 
718
685
# These are characters that if escaped, should stay that way
719
686
_no_decode_chars = ';/?:@&=+$,#'
720
687
_no_decode_ords = [ord(c) for c in _no_decode_chars]
721
688
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
722
 
                  + ['%02X' % o for o in _no_decode_ords])
723
 
_hex_display_map = dict(([('%02x' % o, int2byte(o)) for o in range(256)]
724
 
                         + [('%02X' % o, int2byte(o)) for o in range(256)]))
725
 
# These entries get mapped to themselves
726
 
_hex_display_map.update((hex, b'%' + hex.encode('ascii'))
727
 
                        for hex in _no_decode_hex)
 
689
                + ['%02X' % o for o in _no_decode_ords])
 
690
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
 
691
                    + [('%02X' % o, chr(o)) for o in range(256)]))
 
692
#These entries get mapped to themselves
 
693
_hex_display_map.update((hex, '%'+hex) for hex in _no_decode_hex)
728
694
 
729
695
# These characters shouldn't be percent-encoded, and it's always safe to
730
696
# unencode them if they are.
731
697
_url_dont_escape_characters = set(
732
 
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
733
 
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
734
 
    "0123456789"  # Numbers
735
 
    "-._~"  # Unreserved characters
 
698
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
699
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
700
   "0123456789" # Numbers
 
701
   "-._~"  # Unreserved characters
736
702
)
737
703
 
738
704
# These characters should not be escaped
739
705
_url_safe_characters = set(
740
 
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
741
 
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
742
 
    "0123456789"  # Numbers
743
 
    "_.-!~*'()"  # Unreserved characters
744
 
    "/;?:@&=+$,"  # Reserved characters
745
 
    "%#"         # Extra reserved characters
 
706
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
707
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
708
   "0123456789" # Numbers
 
709
   "_.-!~*'()"  # Unreserved characters
 
710
   "/;?:@&=+$," # Reserved characters
 
711
   "%#"         # Extra reserved characters
746
712
)
747
713
 
748
 
 
749
 
def _unescape_segment_for_display(segment, encoding):
750
 
    """Unescape a segment for display.
751
 
 
752
 
    Helper for unescape_for_display
753
 
 
754
 
    :param url: A 7-bit ASCII URL
755
 
    :param encoding: The final output encoding
756
 
 
757
 
    :return: A unicode string which can be safely encoded into the
758
 
         specified encoding.
759
 
    """
760
 
    escaped_chunks = segment.split('%')
761
 
    escaped_chunks[0] = escaped_chunks[0].encode('utf-8')
762
 
    for j in range(1, len(escaped_chunks)):
763
 
        item = escaped_chunks[j]
764
 
        try:
765
 
            escaped_chunks[j] = _hex_display_map[item[:2]]
766
 
        except KeyError:
767
 
            # Put back the percent symbol
768
 
            escaped_chunks[j] = b'%' + \
769
 
                (item[:2].encode('utf-8') if PY3 else item[:2])
770
 
        except UnicodeDecodeError:
771
 
            escaped_chunks[j] = unichr(int(item[:2], 16)).encode('utf-8')
772
 
        escaped_chunks[j] += (item[2:].encode('utf-8') if PY3 else item[2:])
773
 
    unescaped = b''.join(escaped_chunks)
774
 
    try:
775
 
        decoded = unescaped.decode('utf-8')
776
 
    except UnicodeDecodeError:
777
 
        # If this path segment cannot be properly utf-8 decoded
778
 
        # after doing unescaping we will just leave it alone
779
 
        return segment
780
 
    else:
781
 
        try:
782
 
            decoded.encode(encoding)
783
 
        except UnicodeEncodeError:
784
 
            # If this chunk cannot be encoded in the local
785
 
            # encoding, then we should leave it alone
786
 
            return segment
787
 
        else:
788
 
            # Otherwise take the url decoded one
789
 
            return decoded
790
 
 
791
 
 
792
714
def unescape_for_display(url, encoding):
793
715
    """Decode what you can for a URL, so that we get a nice looking path.
794
716
 
817
739
    # Split into sections to try to decode utf-8
818
740
    res = url.split('/')
819
741
    for i in range(1, len(res)):
820
 
        res[i] = _unescape_segment_for_display(res[i], encoding)
 
742
        escaped_chunks = res[i].split('%')
 
743
        for j in range(1, len(escaped_chunks)):
 
744
            item = escaped_chunks[j]
 
745
            try:
 
746
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
 
747
            except KeyError:
 
748
                # Put back the percent symbol
 
749
                escaped_chunks[j] = '%' + item
 
750
            except UnicodeDecodeError:
 
751
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
 
752
        unescaped = ''.join(escaped_chunks)
 
753
        if sys.version_info[0] == 2:
 
754
            try:
 
755
                decoded = unescaped.decode('utf-8')
 
756
            except UnicodeDecodeError:
 
757
                # If this path segment cannot be properly utf-8 decoded
 
758
                # after doing unescaping we will just leave it alone
 
759
                pass
 
760
            else:
 
761
                try:
 
762
                    decoded.encode(encoding)
 
763
                except UnicodeEncodeError:
 
764
                    # If this chunk cannot be encoded in the local
 
765
                    # encoding, then we should leave it alone
 
766
                    pass
 
767
                else:
 
768
                    # Otherwise take the url decoded one
 
769
                    res[i] = decoded
 
770
        else:
 
771
            res[i] = unescaped
821
772
    return u'/'.join(res)
822
773
 
823
774
 
832
783
    is used without a path, e.g. c:foo-bar => foo-bar.
833
784
    If no /, path separator or : is found, the from_location is returned.
834
785
    """
835
 
    from_location = strip_segment_parameters(from_location)
836
786
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
837
787
        return os.path.basename(from_location.rstrip("/\\"))
838
788
    else:
839
789
        sep = from_location.find(":")
840
790
        if sep > 0:
841
 
            return from_location[sep + 1:]
 
791
            return from_location[sep+1:]
842
792
        else:
843
793
            return from_location
844
794
 
872
822
    to_segments = osutils.splitpath(to_path)
873
823
    count = -1
874
824
    for count, (from_element, to_element) in enumerate(zip(from_segments,
875
 
                                                           to_segments)):
 
825
                                                       to_segments)):
876
826
        if from_element != to_element:
877
827
            break
878
828
    else:
889
839
    """Parsed URL."""
890
840
 
891
841
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
892
 
                 port, quoted_path):
 
842
            port, quoted_path):
893
843
        self.scheme = scheme
894
844
        self.quoted_host = quoted_host
895
845
        self.host = unquote(self.quoted_host)
904
854
        else:
905
855
            self.password = None
906
856
        self.port = port
907
 
        self.quoted_path = _url_hex_escapes_re.sub(
908
 
            _unescape_safe_chars, quoted_path)
 
857
        self.quoted_path = _url_hex_escapes_re.sub(_unescape_safe_chars, quoted_path)
909
858
        self.path = unquote(self.quoted_path)
910
859
 
911
860
    def __eq__(self, other):
929
878
        :param url: URL as bytestring
930
879
        """
931
880
        # GZ 2017-06-09: Actually validate ascii-ness
932
 
        # pad.lv/1696545: For the moment, accept both native strings and
933
 
        # unicode.
 
881
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
934
882
        if isinstance(url, str):
935
883
            pass
936
884
        elif isinstance(url, text_type):
953
901
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
954
902
            # there *is* port
955
903
            host, port = host.rsplit(':', 1)
956
 
            if port:
957
 
                try:
958
 
                    port = int(port)
959
 
                except ValueError:
960
 
                    raise InvalidURL('invalid port number %s in url:\n%s' %
961
 
                                     (port, url))
962
 
            else:
963
 
                port = None
964
 
        if host != "" and host[0] == '[' and host[-1] == ']':  # IPv6
 
904
            try:
 
905
                port = int(port)
 
906
            except ValueError:
 
907
                raise InvalidURL('invalid port number %s in url:\n%s' %
 
908
                                 (port, url))
 
909
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
965
910
            host = host[1:-1]
966
911
 
967
912
        return cls(scheme, user, password, host, port, path)
1000
945
        :param relpath: relative url string for relative part of remote path.
1001
946
        :return: urlencoded string for final path.
1002
947
        """
1003
 
        # pad.lv/1696545: For the moment, accept both native strings and
1004
 
        # unicode.
 
948
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
1005
949
        if isinstance(relpath, str):
1006
950
            pass
1007
951
        elif isinstance(relpath, text_type):
1026
970
                    continue
1027
971
                base_parts.pop()
1028
972
            elif p == '.':
1029
 
                continue  # No-op
 
973
                continue # No-op
1030
974
            elif p != '':
1031
975
                base_parts.append(p)
1032
976
        path = '/'.join(base_parts)
1049
993
        else:
1050
994
            path = self.quoted_path
1051
995
        return self.__class__(self.scheme, self.quoted_user,
1052
 
                              self.quoted_password, self.quoted_host, self.port,
1053
 
                              path)
 
996
                self.quoted_password, self.quoted_host, self.port,
 
997
                path)
1054
998
 
1055
999
 
1056
1000
def parse_url(url):
1065
1009
    """
1066
1010
    parsed_url = URL.from_string(url)
1067
1011
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
1068
 
            parsed_url.host, parsed_url.port, parsed_url.path)
 
1012
        parsed_url.host, parsed_url.port, parsed_url.path)