-=[ Mr. Bumblebee ]=-
_Indonesia_
:Nc @@ s d Z d d l m Z d d l Z d d l Z d d l Z d d l m Z e e d e d Z
e d Z d Z i Z
xf e e d e e e d D]= \ Z Z e d
k r e e k r e n d j e e
e <q Wi Z d d
Z d Z e d e D Z d Z d Z d Z d Z d Z d Z d Z d Z! d Z" d Z# d Z$ e" Z% e! Z& e' d Z( e' d Z) e j* d k re$ Z% e# Z& e) Z( n e j+ d Z, e j+ d Z- d Z. d! Z/ d" Z0 d# Z1 e d$ Z2 d% Z3 d& Z4 d' Z5 d( Z6 d) Z7 d* Z8 d+ Z9 d, Z: g e: D] Z e; e ^ qZZ< g e< D] Z= d- e= ^ qyg e< D] Z= d. e= ^ qZ> e g e? d D] Z= d- e= e@ e= f ^ qg e? d D] Z= d. e= e@ e= f ^ q ZA eA jB d/ e> D eC d0 ZD eC d1 ZE d2 ZF d3 ZG d4 ZH d5 ZI d6 ZJ d7 eK f d8 YZL d9 ZM d S(: s5 A collection of function for handling URL operations.i ( t absolute_importN( t lazy_importsr
from posixpath import split as _posix_split
import urlparse
from bzrlib import (
errors,
osutils,
)
c C@ s t | d | d S( st Return the last component of a URL.
:param url: The URL in question
:param exclude_trailing_slash: If the url looks like "path/to/foo/"
ignore the final slash and return 'foo' rather than ''
:return: Just the final component of the URL. This can return ''
if you don't exclude_trailing_slash, or if you are at the
root of the URL.
t exclude_trailing_slashi ( t split( t urlR ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt basename% s
c C@ s t | d | d S( s4 Return the parent directory of the given path.
:param url: Relative or absolute URL
:param exclude_trailing_slash: Remove a final slash
(treat http://host/foo/ as http://host/foo, but
http://host/ stays http://host/)
:return: Everything in the URL except the last path chunk
R i ( R ( R R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt dirname2 s sA ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.-i i s %{0:02X}t /c C@ s | s% | d k r! t d n | S| t f } y t | \ } } Wnf t k
r t j } | j g | D] } | | f ^ qn | j } t | } | | f t | <n X| j | s | Sd j
t | | S( s quote('abc def') -> 'abc%20def'
Each part of a URL, e.g. the path info, the query, etc., has a
different set of reserved characters that must be quoted.
RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
the following reserved characters.
reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
"$" | ","
Each of these characters is reserved in some component of a URL,
but not necessarily in all of them.
By default, the quote function is intended for quoting the path
section of a URL. Thus, it will not encode '/'. This character
is reserved, but in typical usage the quote function is being
called on a path where the existing slash characters are used as
reserved characters.
s None object cannot be quotedt N( t Nonet TypeErrort always_safet
_safe_quoterst KeyErrort _safe_mapt copyt updatet __getitem__t rstript joint map( t st safet cachekeyt quotert safe_mapt c( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt quoteM s
&
t 0123456789ABCDEFabcdefc c@ s? | ]5 } t D]( } | | t t | | d f Vq
q d S( i N( t _hexdigt chrt int( t .0t at b( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pys <genexpr>v s c C@ s | j d } t | d k r% | S| d } x | d D]{ } y | t | d | d 7} Wq: t k
r | d | 7} q: t k
r | t t | d d | d 7} q: Xq: W| S( s" unquote('abc%20def') -> 'abc def'.t %i i i i ( R t lent _hextochrR
t UnicodeDecodeErrort unichrR ( R t rest item( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt unquotey s
-c C@ s7 t | t r! | j d } n t t | d d S( s! Escape relpath to be a valid url.s utf-8R s /~( t
isinstancet unicodet encodet strR ( t relpath( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt escape s c C@ sk t | t k r+ t d | t f n t j t | } t j t | } t t j | | S( s Compute just the relative sub-portion of a url
This assumes that both paths are already fully specified file:// URLs.
sV Length of base (%r) must equal or exceed the platform minimum url length (which is %d)( R$ t MIN_ABS_FILEURL_LENGTHt
ValueErrort osutilst normpatht local_path_from_urlR0 R/ ( t baset path( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt file_relpath s c C@ s t j | } | s d S| j d } | j d } | j d } | d k rb t | d f St | | | j d f S( s Find the scheme separator (://) and the first path separator
This is just a helper functions for other path utilities.
It could probably be replaced by urlparse
t schemeR7 R iN( NN( t _url_scheme_ret matchR t groupt findR$ t start( R t mR9 R7 t first_path_slash( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _find_scheme_and_separator s c C@ s t j | d k S( s, Tests whether a URL is in actual fact a URL.N( R: R; R ( R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt is_url s c G@ s | s
| St | \ } } | d k r= | d k r= d } n | d k rX t | } n | | } x | D] } t | \ } } | d k r | d k r d } n | d k r t | } n | d k r | } | | } | } | } qi t | | } qi W| | | S( s Create a URL by joining sections.
This will normalize '..', assuming that paths are absolute
(it assumes no symlinks in either path)
If any of *args is an absolute URL, it will be treated correctly.
Example:
join('http://foo', 'http://bar') => 'http://bar'
join('http://foo', 'bar') => 'http://foo/bar'
join('http://foo', 'bar', '../baz') => 'http://foo/baz'
i N( RA R R$ t joinpath( R6 t argst
scheme_endt
path_startR7 t argt arg_scheme_endt arg_path_start( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyR s*
c G@ s | j d } t | d k r> | d d k r> | j n x | D] } | j d rc g } n xv | j d D]e } | d k r qs qs | d k r | d g k r t j d | | n | j qs | j | qs WqE W| d g k r d Sd j | Sd S( s Join URL path segments to a URL path segment.
This is somewhat like osutils.joinpath, but intended for URLs.
XXX: this duplicates some normalisation logic, and also duplicates a lot of
path handling logic that already exists in some Transport implementations.
We really should try to have exactly one place in the code base responsible
for combining paths of URLs.
R i iR t .s ..s Cannot go above rootN( R R$ t popt
startswitht errorst InvalidURLJoint appendR ( R6 RD R7 RG t chunk( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyRC s$
"
c C@ sz t | d } d } | j | r< | t | d } n4 | j d s` t j | d n | t d } t | S( s8 Convert a url like file:///path/to/foo into /path/to/fooi s file://localhost/i s file:///s8 local urls must start with file:/// or file://localhost/s file://( t split_segment_parameters_rawRL R$ RM t
InvalidURLt unescape( R t file_localhost_prefixR7 ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _posix_local_path_from_url s c C@ s d t t j | S( s Convert a local path like ./foo into a URL like file:///path/to/foo
This also handles transforming escaping unicode characters, etc.
s file://( R0 R3 t _posix_abspath( R7 ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _posix_local_path_to_url s c C@ s | j d s$ t j | d n t | d } | t d } | j d s | d d k ss | d d k r t j | d
n t | S| d k r d St | d k s | d d k s | d
d k s | d d k r t j | d n | d j d t | d S( s= Convert a url like file:///C:/path/to/foo into C:/path/to/foos file://sJ local urls must start with file:///, UNC path urls must start with file://i s file:s ///i R i s |:s. Win32 UNC path urls have form file://HOST/pathi t4 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZi i sG Win32 file urls start with file:///x:/, where x is a valid drive letteru :( RL RM RR RQ R$ RS t upper( R t win32_url( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _win32_local_path_from_url s"
c C@ sf | d k r d St j | } | j d r< d t | Sd t | d j d t | d S( s Convert a local path like ./foo into a URL like file:///C:/path/to/foo
This also handles transforming escaping unicode characters, etc.
R s file:///s //s file:i t :i ( R3 t _win32_abspathRL R0 R. RY ( R7 t
win32_path( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _win32_local_path_to_url9 s s file:///s file:///C:/t win32s) ^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$s (%[0-9a-fA-F]{2})c C@ sO | j d d } t t | d } | t k r8 | S| j d j Sd S( st re.sub callback to convert hex-escapes to plain characters (if safe).
e.g. '%7E' will be converted to '~'.
i i i N( R< R R t _url_dont_escape_charactersRY ( t matchobjt
hex_digitst char( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _unescape_safe_chars_ s
c C@ se t | \ } } | d k r( t | S| | } | | } t | t s x3 | D]+ } | t k rR t j | d | qR qR Wt j t
| } t | d j | St
| } x} t t | D]i } | | t k r | | j d } d j g | | j d D] } d t | ^ q | | <q q Wd j | } t j t
| } t | | S( sI Make sure that a path string is in fully normalized URL form.
This handles URLs which have unicode characters, spaces,
special characters, etc.
It has two basic modes of operation, depending on whether the
supplied string starts with a url specifier (scheme://) or not.
If it does not have a specifier it is considered a local path,
and will be converted into a file:/// url. Non-ascii characters
will be encoded using utf-8.
If it does have a url specifier, it will be treated as a "hybrid"
URL. Basically, a URL that should have URL special characters already
escaped (like +?&# etc), but may have unicode characters, etc
which would not be valid in a real URL.
:param url: Either a hybrid URL or a local path
:return: A normalized URL which only includes 7-bit ASCII characters.
s7 URLs can only contain specific safe characters (not %r)R s utf-8s %%%02XN( RA R t local_path_to_urlR+ R, t _url_safe_charactersRM RR t _url_hex_escapes_ret subRe R. R t listt xrangeR$ R- t ord( R RE RF t prefixR7 R t
path_charst it chars( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt
normalize_urll s*
>c C@ s t | \ } } | d
k r" | St | \ } } | d
k rD | S| | } | | } | | k rh | St j d k r | d k r | | d | d !} | | d | d !} | | k r | Sn | | d } | | d }
| j d r | d } n | j d } |
j d } | d g k r.g } n | d g k rFg } n g }
x: t | | D]) \ } } | | k rxPn |
j | q\Wt |
} g | | D] } d ^ q}
|
j | | d j
|
pd S( s Return a path to other from base.
If other is unrelated to base, return other. Else return a relative path.
This assumes no symlinks as part of the url.
R` s file://i i R iR s ..RJ N( RA R t syst platformt endswithR t zipRO R$ t extendR ( R6 t othert dummyt base_first_slasht other_first_slasht base_schemet other_schemet
base_drivet other_drivet base_patht
other_patht
base_sectionst other_sectionst output_sectionsR" t ot match_lent x( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt relative_url sD
c C@ sp t | d k s2 | d d k s2 | d d k rK t j | | d n | | d d !7} | d } | | f S( s< On win32 the drive letter needs to be added to the url base.i i s :|i R s( win32 file:/// paths need a drive letteri ( R$ RM RR ( t url_baseR7 ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _win32_extract_drive_letter s 2
c C@ s t | \ } } | d k rc | d k rV | rL | j d rL | d } n t | S| d f Sn | | } | | } t j d k r | j d r t | | \ } } n | r t | d k r | j d r | d } n t | \ } } | | | f S( sf Split a URL into its parent directory and a child directory.
:param url: A relative or absolute URL
:param exclude_trailing_slash: Strip off a final '/' if it is part
of the path (but not if it is part of the protocol specification)
:return: (parent_url, child_dir). child_dir may be the empty string if we're at
the root.
R iR R` s file:///i N( RA R Rt t _posix_splitRr Rs RL R R$ ( R R t
scheme_locR@ R R7 t headt tail( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyR s
'
c C@ s` t | } | j d | j d d } | d k rA | g f S| | | | d j d f S( s Split the subsegment of the last segment of a URL.
:param url: A relative or absolute URL
:return: (url, subsegments)
t ,R i i( t strip_trailing_slashR= t rfindR ( R t lurlt
segment_start( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyRQ s
c C@ sU t | \ } } i } x0 | D]( } | j d d \ } } | | | <q W| | f S( s Split the segment parameters of the last segment of a URL.
:param url: A relative or absolute URL
:return: (url, segment_parameters)
t =i ( RQ R ( R t base_urlt subsegmentst
parameterst
subsegmentt keyt value( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt split_segment_parameters s
c G@ sx | s
| SxW | D]O } t | t k r< t d | n d | k r t j d | | q q Wd j | f | S( s Create a new URL by adding subsegments to an existing one.
This adds the specified subsegments to the last path in the specified
base URL. The subsegments should be bytestrings.
:note: You probably want to use join_segment_parameters instead.
s! Subsegment %r is not a bytestringR s , exists in subsegments( t typeR. R
RM RN R ( R6 R R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt join_segment_parameters_raw s
c C@ s t | \ } } i } | j | x | j D] \ } } t | t k rc t d | n t | t k r t d | | f n d | k r t j d | | n | | | <q2 Wt | g t | j
D] } d | ^ q S( sH Create a new URL by adding segment parameters to an existing one.
The parameters of the last segment in the URL will be updated; if a
parameter with the same key already exists it will be overwritten.
:param url: A URL, as string
:param parameters: Dictionary of parameters, keys and values as bytestrings
s$ parameter key %r is not a bytestrings- parameter value %r for %s is not a bytestringR s = exists in parameter keys %s=%s( R R t iteritemsR R. R
RM RN R t sortedt items( R R R6 t existing_parameterst new_parametersR R R) ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt join_segment_parameters3 s
c C@ s" t | t k r | d S| Sd S( s$ Strip slashes after the drive letteriN( R$ t WIN32_MIN_ABS_FILEURL_LENGTH( R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt! _win32_strip_local_trailing_slashM s c C@ s | j d s | St j d k r; | j d r; t | St | \ } } | d k ra | d S| d k s | t | d k r | S| d S( s Strip trailing slash, except for root paths.
The definition of 'root path' is platform-dependent.
This assumes that all URLs are valid netloc urls, such that they
form:
scheme://host/path
It searches for ://, and then refuses to remove the next '/'.
It can also handle relative paths
Examples:
path/to/foo => path/to/foo
path/to/foo/ => path/to/foo
http://host/path/ => http://host/path
http://host/path => http://host/path
http://host/ => http://host/
file:/// => file:///
file:///foo/ => file:///foo
# This is unique on win32 platforms, and is the only URL
# format which does it differently.
file:///c|/ => file:///c:/
R R` s file://ii N( Rt Rr Rs RL R RA R R$ ( R R R@ ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyR U s
"c C@ s y t | } Wn, t k
r> } t j | d | f n Xt | } y | j d } Wn, t k
r } t j | d | f n X| S( sR Unescape relpath from url format.
This returns a Unicode path from a URL
s! URL was not a plain ASCII url: %ss utf-8s% Unable to encode the URL as utf-8: %s( R. t UnicodeErrorRM RR R* t decode( R t et unquotedt unicode_path( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyRS ~ s s ;/?:@&=+$,#s %02xs %02Xc c@ s | ] } | d | f Vq d S( R# N( ( R t hex( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pys <genexpr> s sB abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~sS abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.-!~*'()/;?:@&=+$,%#c
C@ s | d k r t d n | j d rc y! t | } | j | | SWqc t k
r_ | SXn | j d } x4t d t | D] } | | j d } x t d t | D] } | | } y t | d | d | | <Wq t
k
rd | | | <q t k
r;t t
| d d | d | | <q Xq Wd j | } y | j d } Wn t k
ruq Xy | j | Wn t k
rq X| | | <q Wd
j | S( s Decode what you can for a URL, so that we get a nice looking path.
This will turn file:// urls into local paths, and try to decode
any portions of a http:// style url that it can.
Any sections of the URL which can't be represented in the encoding or
need to stay as escapes are left alone.
:param url: A 7-bit ASCII URL
:param encoding: The final output encoding
:return: A unicode string which can be safely encoded into the
specified encoding.
s0 you cannot specify None for the display encodings file://R i R# i i R s utf-8u /N( R R2 RL R5 R- R R Rk R$ t _hex_display_mapR
R& R' R R R t UnicodeEncodeError(
R t encodingR7 R( Ro t escaped_chunkst jR) t unescapedt decoded( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt unescape_for_display s>
-
c C@ su | j d d k s- | j t j d k rF t j j | j d S| j d } | d k rm | | d S| Sd S( s Derive a TO_LOCATION given a FROM_LOCATION.
The normal case is a FROM_LOCATION of http://foo/bar => bar.
The Right Thing for some logical destinations may differ though
because no / may be present at all. In that case, the result is
the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
This latter case also applies when a Windows drive
is used without a path, e.g. c:foo-bar => foo-bar.
If no /, path separator or : is found, the from_location is returned.
R i s /\R\ i N( R= t ost sepR7 R R ( t
from_locationR ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt derive_to_location s - c C@ s t j d | | k S( Ns /foo( R3 t pathjoin( R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _is_absolute s c C@ s t | \ } } | d k r" | St | r2 | St j | } t j | } | d | d k ry t j | | n t | d t | d | S( s Convert a relative path from an old base URL to a new base URL.
The result will be a relative path.
Absolute paths and full URLs are returned unaltered.
i N( RA R R t urlparseRM t InvalidRebaseURLst determine_relative_pathR ( R t old_baset new_baseR9 t separatort
old_parsedt
new_parsed( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt
rebase_url s
c
C@ s t j | } t j | } d } xC t t | | D]" \ } \ } } | | k r: Pq: q: W| d 7} | | } | | } d g t | | } t | d k r d St j | S( s4 Determine a relative path from from_path to to_path.ii s ..i RJ ( R3 t splitpatht enumerateRu R$ R (
t from_patht to_patht
from_segmentst to_segmentst countt from_elementt
to_elementt unique_fromt unique_tot segments( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyR s
t URLc B@ s\ e Z d Z d Z d Z d Z e d Z d Z e d Z
d d Z RS( s Parsed URL.c C@ s | | _ | | _ t | j | _ | | _ | j d k rQ t | j | _ n d | _ | | _ | j d k r t | j | _ n d | _ | | _ t
j t | | _
t | j
| _ d S( N( R9 t quoted_hostR* t hostt quoted_userR t usert quoted_passwordt passwordt portRh Ri Re t quoted_pathR7 ( t selfR9 R R R R R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt __init__0 s c C@ sj t | | j oi | j | j k oi | j | j k oi | j | j k oi | j | j k oi | j | j k S( N( R+ t __class__R9 R R R R7 ( R Rw ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt __eq__C s c C@ s5 d | j j | j | j | j | j | j | j f S( Ns <%s(%r, %r, %r, %r, %r, %r)>( R t __name__R9 R R R R R ( R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt __repr__K s c C@ s t | t r% t j d | n | j d } t j | d t \ } } } } } } d
} } }
} d | k r | j d d \ } }
d | k r | j d d \ } } q n | }
d |
k rF|
d d k o |
d d
k rF|
j d d \ }
} y t
| } WqFt k
rBt j d | | f qFXn |
d k r|
d d k r|
d d
k r|
d d !}
n | | | | |
| | S( sR Create a URL object from a string.
:param url: URL as bytestring
s should be ascii:
%rs utf-8t allow_fragmentst @i R\ i t [it ]s! invalid port number %s in url:
%sR N( R+ R, RM RR R- R t FalseR t rsplitR R R2 ( t clsR R9 t netlocR7 t paramst queryt fragmentR R R R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt from_stringQ s( ' -
,c C@ s | j } d | k r" d | } n | j d k rG d | j | f } n | j d k rl d | | j f } n t j | j | | j d d d f S( NR\ s [%s]s %s@%ss %s:%d( R R R R R t
urlunparseR9 R ( R R ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt __str__q s
c C@ s1 t | t s! t j | n t j t | } | j d rK g } n | j d } t | d k r | d d k r | d } n xv | j d D]e } | d k r t | d k r q n | j
q | d k r q q | d k r | j | q q Wd j | } | j d s-d | } n | S( sl Transform a Transport-relative path to a remote absolute path.
This does not handle substitution of ~ but does handle '..' and '.'
components.
Examples::
t._combine_paths('/home/sarah', 'project/foo')
=> '/home/sarah/project/foo'
t._combine_paths('/home/sarah', '../../etc')
=> '/etc'
t._combine_paths('/home/sarah', '/etc')
=> '/etc'
:param base_path: base path
:param relpath: relative url string for relative part of remote path.
:return: urlencoded string for final path.
R i iR s ..RJ (
R+ R. RM RR Rh Ri Re RL R R$ RK RO R ( R R/ t
base_partst pR7 ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt _combine_paths s* "
c C@ s | d k rK t | j d } | j | j | } t | d d } n | j } | j | j | j | j
| j | j | S( s Return a new URL for a path relative to this URL.
:param offset: A relative path, already urlencoded
:return: `URL` instance
s utf-8R s /~N(
R RS R- R R7 R R R R9 R R R R ( R t offsett relativeR7 ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt clone s N(
R t
__module__t __doc__R R R t classmethodR R t staticmethodR R R ( ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyR - s -c C@ s7 t j | } | j | j | j | j | j | j f S( s" Extract the server address, the credentials and the path from the url.
user, password, host and path should be quoted if they contain reserved
chars.
:param url: an quoted url
:return: (scheme, user, password, host, port, path) tuple, all fields
are unquoted.
( R R R9 R R R R R7 ( R t
parsed_url( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt parse_url s
(N R t
__future__R R t reRr t bzrlib.lazy_importR t globalst TrueR R R R Ru Rk R. t bytearrayRo R t formatR R R t dictR% R* R0 R8 RA RB R RC RU RW R[ R_ Rf R5 R$ R1 R Rs t compileR: Rh Re Rq R R R RQ R R R R R RS t _no_decode_charsRl t _no_decode_ordsR t _no_decode_hext rangeR R R t setRa Rg R R R R R t objectR R ( ( ( s3 /usr/lib/python2.7/dist-packages/bzrlib/urlutils.pyt <module> s
45 (
$ "
- 4 ( ) /3 :
Copyright © 2017 || Recoded By Mr.Bumblebee