/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

  • Committer: Jelmer Vernooij
  • Date: 2018-06-14 17:59:16 UTC
  • mto: This revision was merged to the branch mainline in revision 7065.
  • Revision ID: jelmer@jelmer.uk-20180614175916-a2e2xh5k533guq1x
Move breezy.plugins.git to breezy.git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/urlutils.py
16
16
 
17
17
"""A collection of function for handling URL operations."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import os
20
22
import re
21
23
import sys
22
24
 
23
 
from urllib import parse as urlparse
 
25
try:
 
26
    import urlparse
 
27
except ImportError:
 
28
    from urllib import parse as urlparse
24
29
 
25
30
from . import (
26
31
    errors,
32
37
from posixpath import split as _posix_split
33
38
""")
34
39
 
 
40
from .sixish import (
 
41
    PY3,
 
42
    text_type,
 
43
    )
35
44
 
36
45
 
37
46
class InvalidURL(errors.PathError):
57
66
    def __init__(self, from_, to):
58
67
        self.from_ = from_
59
68
        self.to = to
60
 
        errors.PathError.__init__(
61
 
            self, from_, 'URLs differ by more than path.')
 
69
        errors.PathError.__init__(self, from_, 'URLs differ by more than path.')
62
70
 
63
71
 
64
72
def basename(url, exclude_trailing_slash=True):
88
96
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
89
97
 
90
98
 
91
 
quote_from_bytes = urlparse.quote_from_bytes
92
 
quote = urlparse.quote
93
 
unquote_to_bytes = urlparse.unquote_to_bytes
 
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))
 
150
 
 
151
 
94
152
unquote = urlparse.unquote
95
153
 
96
154
 
97
 
def escape(relpath, safe='/~'):
 
155
def escape(relpath):
98
156
    """Escape relpath to be a valid url."""
99
 
    return quote(relpath, safe=safe)
 
157
    if not isinstance(relpath, str):
 
158
        relpath = relpath.encode('utf-8')
 
159
    return quote(relpath, safe='/~')
100
160
 
101
161
 
102
162
def file_relpath(base, path):
106
166
    """
107
167
    if len(base) < MIN_ABS_FILEURL_LENGTH:
108
168
        raise ValueError('Length of base (%r) must equal or'
109
 
                         ' exceed the platform minimum url length (which is %d)' %
110
 
                         (base, MIN_ABS_FILEURL_LENGTH))
 
169
            ' exceed the platform minimum url length (which is %d)' %
 
170
            (base, MIN_ABS_FILEURL_LENGTH))
111
171
    base = osutils.normpath(local_path_from_url(base))
112
172
    path = osutils.normpath(local_path_from_url(path))
113
173
    return escape(osutils.relpath(base, path))
131
191
    first_path_slash = path.find('/')
132
192
    if first_path_slash == -1:
133
193
        return len(scheme), None
134
 
    return len(scheme), first_path_slash + m.start('path')
 
194
    return len(scheme), first_path_slash+m.start('path')
135
195
 
136
196
 
137
197
def is_url(url):
187
247
    """
188
248
    path = base.split('/')
189
249
    if len(path) > 1 and path[-1] == '':
190
 
        # If the path ends in a trailing /, remove it.
 
250
        #If the path ends in a trailing /, remove it.
191
251
        path.pop()
192
252
    for arg in args:
193
253
        if arg.startswith('/'):
198
258
            elif chunk == '..':
199
259
                if path == ['']:
200
260
                    raise InvalidURLJoin('Cannot go above root',
201
 
                                         base, args)
 
261
                            base, args)
202
262
                path.pop()
203
263
            else:
204
264
                path.append(chunk)
211
271
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
212
272
def _posix_local_path_from_url(url):
213
273
    """Convert a url like file:///path/to/foo into /path/to/foo"""
214
 
    url = strip_segment_parameters(url)
 
274
    url = split_segment_parameters_raw(url)[0]
215
275
    file_localhost_prefix = 'file://localhost/'
216
276
    if url.startswith(file_localhost_prefix):
217
277
        path = url[len(file_localhost_prefix) - 1:]
238
298
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
239
299
    if not url.startswith('file://'):
240
300
        raise InvalidURL(url, 'local urls must start with file:///, '
241
 
                         'UNC path urls must start with file://')
242
 
    url = strip_segment_parameters(url)
 
301
                                     'UNC path urls must start with file://')
 
302
    url = split_segment_parameters_raw(url)[0]
243
303
    # We strip off all 3 slashes
244
304
    win32_url = url[len('file:'):]
245
305
    # check for UNC path: //HOST/path
246
306
    if not win32_url.startswith('///'):
247
307
        if (win32_url[2] == '/'
248
 
                or win32_url[3] in '|:'):
 
308
            or win32_url[3] in '|:'):
249
309
            raise InvalidURL(url, 'Win32 UNC path urls'
250
 
                             ' have form file://HOST/path')
 
310
                ' have form file://HOST/path')
251
311
        return unescape(win32_url)
252
312
 
253
313
    # allow empty paths so we can serve all roots
257
317
    # usual local path with drive letter
258
318
    if (len(win32_url) < 6
259
319
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
260
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ') or
261
 
        win32_url[4] not in '|:'
262
 
            or win32_url[5] != '/'):
 
320
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
321
        or win32_url[4] not in  '|:'
 
322
        or win32_url[5] != '/'):
263
323
        raise InvalidURL(url, 'Win32 file urls start with'
264
 
                         ' file:///x:/, where x is a valid drive letter')
 
324
                ' file:///x:/, where x is a valid drive letter')
265
325
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
266
326
 
267
327
 
284
344
    if win32_path.startswith('//'):
285
345
        return 'file:' + escape(win32_path)
286
346
    return ('file:///' + str(win32_path[0].upper()) + ':' +
287
 
            escape(win32_path[2:]))
 
347
        escape(win32_path[2:]))
288
348
 
289
349
 
290
350
local_path_to_url = _posix_local_path_to_url
340
400
        return local_path_to_url(url)
341
401
    prefix = url[:path_start]
342
402
    path = url[path_start:]
343
 
    if not isinstance(url, str):
 
403
    if not isinstance(url, text_type):
344
404
        for c in url:
345
405
            if c not in _url_safe_characters:
346
406
                raise InvalidURL(url, 'URLs can only contain specific'
347
 
                                 ' safe characters (not %r)' % c)
 
407
                                            ' safe characters (not %r)' % c)
348
408
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
349
409
        return str(prefix + ''.join(path))
350
410
 
353
413
 
354
414
    for i in range(len(path_chars)):
355
415
        if path_chars[i] not in _url_safe_characters:
 
416
            chars = path_chars[i].encode('utf-8')
356
417
            path_chars[i] = ''.join(
357
 
                ['%%%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')])
358
419
    path = ''.join(path_chars)
359
420
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
360
421
    return str(prefix + path)
380
441
    if base_scheme != other_scheme:
381
442
        return other
382
443
    elif sys.platform == 'win32' and base_scheme == 'file://':
383
 
        base_drive = base[base_first_slash + 1:base_first_slash + 3]
384
 
        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]
385
446
        if base_drive != other_drive:
386
447
            return other
387
448
 
388
 
    base_path = base[base_first_slash + 1:]
389
 
    other_path = other[other_first_slash + 1:]
 
449
    base_path = base[base_first_slash+1:]
 
450
    other_path = other[other_first_slash+1:]
390
451
 
391
452
    if base_path.endswith('/'):
392
453
        base_path = base_path[:-1]
418
479
    # path is currently /C:/foo
419
480
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
420
481
        raise InvalidURL(url_base + path,
421
 
                         'win32 file:/// paths need a drive letter')
422
 
    url_base += path[0:3]  # file:// + /C:
423
 
    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
424
485
    return url_base, path
425
486
 
426
487
 
431
492
    :param exclude_trailing_slash: Strip off a final '/' if it is part
432
493
        of the path (but not if it is part of the protocol specification)
433
494
 
434
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if
435
 
        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.
436
497
    """
437
498
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
438
499
 
448
509
            return url, ''
449
510
 
450
511
    # We have a fully defined path
451
 
    url_base = url[:first_path_slash]  # http://host, file://
452
 
    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
453
514
 
454
515
    if sys.platform == 'win32' and url.startswith('file:///'):
455
516
        # Strip off the drive letter
472
533
    """
473
534
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
474
535
    #                operates on urls not url+segments, and Transport classes
475
 
    #                should not be blindly adding slashes in the first place.
 
536
    #                should not be blindly adding slashes in the first place. 
476
537
    lurl = strip_trailing_slash(url)
477
538
    # Segments begin at first comma after last forward slash, if one exists
478
 
    segment_start = lurl.find(",", lurl.rfind("/") + 1)
 
539
    segment_start = lurl.find(",", lurl.rfind("/")+1)
479
540
    if segment_start == -1:
480
541
        return (url, [])
481
 
    return (lurl[:segment_start],
482
 
            [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(",")])
483
543
 
484
544
 
485
545
def split_segment_parameters(url):
491
551
    (base_url, subsegments) = split_segment_parameters_raw(url)
492
552
    parameters = {}
493
553
    for subsegment in subsegments:
494
 
        try:
495
 
            (key, value) = subsegment.split("=", 1)
496
 
        except ValueError:
497
 
            raise InvalidURL(url, "missing = in subsegment")
 
554
        (key, value) = subsegment.split("=", 1)
498
555
        if not isinstance(key, str):
499
556
            raise TypeError(key)
500
557
        if not isinstance(value, str):
503
560
    return (base_url, parameters)
504
561
 
505
562
 
506
 
def strip_segment_parameters(url):
507
 
    """Strip the segment parameters from a URL.
508
 
 
509
 
    :param url: A relative or absolute URL
510
 
    :return: url
511
 
    """
512
 
    base_url, subsegments = split_segment_parameters_raw(url)
513
 
    return base_url
514
 
 
515
 
 
516
563
def join_segment_parameters_raw(base, *subsegments):
517
 
    """Create a new URL by adding subsegments to an existing one.
 
564
    """Create a new URL by adding subsegments to an existing one. 
518
565
 
519
566
    This adds the specified subsegments to the last path in the specified
520
567
    base URL. The subsegments should be bytestrings.
528
575
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
529
576
        if "," in subsegment:
530
577
            raise InvalidURLJoin(", exists in subsegments",
531
 
                                 base, subsegments)
 
578
                                        base, subsegments)
532
579
    return ",".join((base,) + subsegments)
533
580
 
534
581
 
546
593
    new_parameters.update(existing_parameters)
547
594
    for key, value in parameters.items():
548
595
        if not isinstance(key, str):
549
 
            raise TypeError("parameter key %r is not a str" % key)
 
596
            raise TypeError("parameter key %r is not a bytestring" % key)
550
597
        if not isinstance(value, str):
551
 
            raise TypeError("parameter value %r for %r is not a str" %
552
 
                            (value, key))
 
598
            raise TypeError("parameter value %r for %s is not a bytestring" %
 
599
                (key, value))
553
600
        if "=" in key:
554
601
            raise InvalidURLJoin("= exists in parameter key", url,
555
 
                                 parameters)
 
602
                parameters)
556
603
        new_parameters[key] = value
557
 
    return join_segment_parameters_raw(
558
 
        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())])
559
606
 
560
607
 
561
608
def _win32_strip_local_trailing_slash(url):
599
646
        # so just chop off the last character
600
647
        return url[:-1]
601
648
 
602
 
    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:
603
650
        # Don't chop off anything if the only slash is the path
604
651
        # separating slash
605
652
        return url
619
666
    #       plain ASCII strings, or the final .decode will
620
667
    #       try to encode the UNICODE => ASCII, and then decode
621
668
    #       it into utf-8.
622
 
 
623
 
    if isinstance(url, str):
 
669
    if isinstance(url, text_type):
624
670
        try:
625
 
            url.encode("ascii")
 
671
            url = url.encode("ascii")
626
672
        except UnicodeError as e:
627
 
            raise InvalidURL(
628
 
                url, 'URL was not a plain ASCII url: %s' % (e,))
629
 
    return urlparse.unquote(url)
 
673
            raise InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
 
674
    if PY3:
 
675
        unquoted = urlparse.unquote_to_bytes(url)
 
676
    else:
 
677
        unquoted = unquote(url)
 
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
630
683
 
631
684
 
632
685
# These are characters that if escaped, should stay that way
633
686
_no_decode_chars = ';/?:@&=+$,#'
634
687
_no_decode_ords = [ord(c) for c in _no_decode_chars]
635
688
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
636
 
                  + ['%02X' % o for o in _no_decode_ords])
637
 
_hex_display_map = dict(([('%02x' % o, bytes([o])) for o in range(256)]
638
 
                         + [('%02X' % o, bytes([o])) for o in range(256)]))
639
 
# These entries get mapped to themselves
640
 
_hex_display_map.update((hex, b'%' + hex.encode('ascii'))
641
 
                        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)
642
694
 
643
695
# These characters shouldn't be percent-encoded, and it's always safe to
644
696
# unencode them if they are.
645
697
_url_dont_escape_characters = set(
646
 
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
647
 
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
648
 
    "0123456789"  # Numbers
649
 
    "-._~"  # Unreserved characters
 
698
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
699
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
700
   "0123456789" # Numbers
 
701
   "-._~"  # Unreserved characters
650
702
)
651
703
 
652
704
# These characters should not be escaped
653
705
_url_safe_characters = set(
654
 
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
655
 
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
656
 
    "0123456789"  # Numbers
657
 
    "_.-!~*'()"  # Unreserved characters
658
 
    "/;?:@&=+$,"  # Reserved characters
659
 
    "%#"         # Extra reserved characters
 
706
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
707
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
708
   "0123456789" # Numbers
 
709
   "_.-!~*'()"  # Unreserved characters
 
710
   "/;?:@&=+$," # Reserved characters
 
711
   "%#"         # Extra reserved characters
660
712
)
661
713
 
662
 
 
663
 
def _unescape_segment_for_display(segment, encoding):
664
 
    """Unescape a segment for display.
665
 
 
666
 
    Helper for unescape_for_display
667
 
 
668
 
    :param url: A 7-bit ASCII URL
669
 
    :param encoding: The final output encoding
670
 
 
671
 
    :return: A unicode string which can be safely encoded into the
672
 
         specified encoding.
673
 
    """
674
 
    escaped_chunks = segment.split('%')
675
 
    escaped_chunks[0] = escaped_chunks[0].encode('utf-8')
676
 
    for j in range(1, len(escaped_chunks)):
677
 
        item = escaped_chunks[j]
678
 
        try:
679
 
            escaped_chunks[j] = _hex_display_map[item[:2]]
680
 
        except KeyError:
681
 
            # Put back the percent symbol
682
 
            escaped_chunks[j] = b'%' + (item[:2].encode('utf-8'))
683
 
        except UnicodeDecodeError:
684
 
            escaped_chunks[j] = chr(int(item[:2], 16)).encode('utf-8')
685
 
        escaped_chunks[j] += (item[2:].encode('utf-8'))
686
 
    unescaped = b''.join(escaped_chunks)
687
 
    try:
688
 
        decoded = unescaped.decode('utf-8')
689
 
    except UnicodeDecodeError:
690
 
        # If this path segment cannot be properly utf-8 decoded
691
 
        # after doing unescaping we will just leave it alone
692
 
        return segment
693
 
    else:
694
 
        try:
695
 
            decoded.encode(encoding)
696
 
        except UnicodeEncodeError:
697
 
            # If this chunk cannot be encoded in the local
698
 
            # encoding, then we should leave it alone
699
 
            return segment
700
 
        else:
701
 
            # Otherwise take the url decoded one
702
 
            return decoded
703
 
 
704
 
 
705
714
def unescape_for_display(url, encoding):
706
715
    """Decode what you can for a URL, so that we get a nice looking path.
707
716
 
730
739
    # Split into sections to try to decode utf-8
731
740
    res = url.split('/')
732
741
    for i in range(1, len(res)):
733
 
        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
734
772
    return u'/'.join(res)
735
773
 
736
774
 
745
783
    is used without a path, e.g. c:foo-bar => foo-bar.
746
784
    If no /, path separator or : is found, the from_location is returned.
747
785
    """
748
 
    from_location = strip_segment_parameters(from_location)
749
786
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
750
787
        return os.path.basename(from_location.rstrip("/\\"))
751
788
    else:
752
789
        sep = from_location.find(":")
753
790
        if sep > 0:
754
 
            return from_location[sep + 1:]
 
791
            return from_location[sep+1:]
755
792
        else:
756
793
            return from_location
757
794
 
785
822
    to_segments = osutils.splitpath(to_path)
786
823
    count = -1
787
824
    for count, (from_element, to_element) in enumerate(zip(from_segments,
788
 
                                                           to_segments)):
 
825
                                                       to_segments)):
789
826
        if from_element != to_element:
790
827
            break
791
828
    else:
802
839
    """Parsed URL."""
803
840
 
804
841
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
805
 
                 port, quoted_path):
 
842
            port, quoted_path):
806
843
        self.scheme = scheme
807
844
        self.quoted_host = quoted_host
808
845
        self.host = unquote(self.quoted_host)
817
854
        else:
818
855
            self.password = None
819
856
        self.port = port
820
 
        self.quoted_path = _url_hex_escapes_re.sub(
821
 
            _unescape_safe_chars, quoted_path)
 
857
        self.quoted_path = _url_hex_escapes_re.sub(_unescape_safe_chars, quoted_path)
822
858
        self.path = unquote(self.quoted_path)
823
859
 
824
860
    def __eq__(self, other):
842
878
        :param url: URL as bytestring
843
879
        """
844
880
        # GZ 2017-06-09: Actually validate ascii-ness
845
 
        # pad.lv/1696545: For the moment, accept both native strings and
846
 
        # unicode.
847
 
        if isinstance(url, str):
848
 
            pass
849
 
        elif isinstance(url, str):
850
 
            try:
851
 
                url = url.encode()
852
 
            except UnicodeEncodeError:
853
 
                raise InvalidURL(url)
854
 
        else:
855
 
            raise InvalidURL(url)
 
881
        if not isinstance(url, str):
 
882
            raise InvalidURL('should be ascii:\n%r' % url)
856
883
        (scheme, netloc, path, params,
857
884
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
858
885
        user = password = host = port = None
866
893
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
867
894
            # there *is* port
868
895
            host, port = host.rsplit(':', 1)
869
 
            if port:
870
 
                try:
871
 
                    port = int(port)
872
 
                except ValueError:
873
 
                    raise InvalidURL('invalid port number %s in url:\n%s' %
874
 
                                     (port, url))
875
 
            else:
876
 
                port = None
877
 
        if host != "" and host[0] == '[' and host[-1] == ']':  # IPv6
 
896
            try:
 
897
                port = int(port)
 
898
            except ValueError:
 
899
                raise InvalidURL('invalid port number %s in url:\n%s' %
 
900
                                 (port, url))
 
901
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
878
902
            host = host[1:-1]
879
903
 
880
904
        return cls(scheme, user, password, host, port, path)
913
937
        :param relpath: relative url string for relative part of remote path.
914
938
        :return: urlencoded string for final path.
915
939
        """
916
 
        # pad.lv/1696545: For the moment, accept both native strings and
917
 
        # unicode.
 
940
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
918
941
        if isinstance(relpath, str):
919
942
            pass
920
 
        elif isinstance(relpath, str):
 
943
        elif isinstance(relpath, unicode):
921
944
            try:
922
945
                relpath = relpath.encode()
923
946
            except UnicodeEncodeError:
939
962
                    continue
940
963
                base_parts.pop()
941
964
            elif p == '.':
942
 
                continue  # No-op
 
965
                continue # No-op
943
966
            elif p != '':
944
967
                base_parts.append(p)
945
968
        path = '/'.join(base_parts)
955
978
        """
956
979
        if offset is not None:
957
980
            relative = unescape(offset)
 
981
            if sys.version_info[0] == 2:
 
982
                relative = relative.encode('utf-8')
958
983
            path = self._combine_paths(self.path, relative)
959
984
            path = quote(path, safe="/~")
960
985
        else:
961
986
            path = self.quoted_path
962
987
        return self.__class__(self.scheme, self.quoted_user,
963
 
                              self.quoted_password, self.quoted_host, self.port,
964
 
                              path)
 
988
                self.quoted_password, self.quoted_host, self.port,
 
989
                path)
965
990
 
966
991
 
967
992
def parse_url(url):
976
1001
    """
977
1002
    parsed_url = URL.from_string(url)
978
1003
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
979
 
            parsed_url.host, parsed_url.port, parsed_url.path)
 
1004
        parsed_url.host, parsed_url.port, parsed_url.path)