FM / python

/usr/lib/python3/dist-packages/twisted/python/

/usr/lib/python3/dist-packages/twisted/python

Name	Size	Mode	Actions
test/	-	0755	rm
_pydoctortemplates/	-	0755	rm
__pycache__/	-	0755	rm
compat.py	16931	0644	edit dl rm
components.py	14199	0644	edit dl rm
constants.py	513	0644	edit dl rm
context.py	4054	0644	edit dl rm
deprecate.py	27668	0644	edit dl rm
failure.py	27007	0644	edit dl rm
fakepwd.py	6732	0644	edit dl rm
filepath.py	54023	0644	edit dl rm
formmethod.py	12107	0644	edit dl rm
htmlizer.py	3626	0644	edit dl rm
lockfile.py	8026	0644	edit dl rm
log.py	22302	0644	edit dl rm
logfile.py	10119	0644	edit dl rm
modules.py	26715	0644	edit dl rm
monkey.py	2164	0644	edit dl rm
procutils.py	1371	0644	edit dl rm
randbytes.py	3459	0644	edit dl rm
rebuild.py	7122	0644	edit dl rm
reflect.py	20480	0644	edit dl rm
release.py	1104	0644	edit dl rm
roots.py	7178	0644	edit dl rm
runtime.py	5924	0644	edit dl rm
sendmsg.py	2682	0644	edit dl rm
shortcut.py	2302	0644	edit dl rm
syslog.py	3652	0644	edit dl rm
systemd.py	2987	0644	edit dl rm
text.py	5417	0644	edit dl rm
threadable.py	3327	0644	edit dl rm
threadpool.py	10203	0644	edit dl rm
twisted-completion.zsh	1371	0644	edit dl rm
url.py	244	0644	edit dl rm
urlpath.py	8447	0644	edit dl rm
usage.py	34577	0644	edit dl rm
util.py	27432	0644	edit dl rm
versions.py	273	0644	edit dl rm
win32.py	4794	0644	edit dl rm
zippath.py	9028	0644	edit dl rm
zipstream.py	9680	0644	edit dl rm
_appdirs.py	820	0644	edit dl rm
_inotify.py	3496	0644	edit dl rm
_pydoctor.py	6735	0644	edit dl rm
_release.py	18879	0644	edit dl rm
_shellcomp.py	25279	0644	edit dl rm
_textattributes.py	9097	0644	edit dl rm
_tzhelper.py	3128	0644	edit dl rm
_url.py	228	0644	edit dl rm
__init__.py	598	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/python/urlpath.py (8447B)

# -*- test-case-name: twisted.python.test.test_urlpath -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
L{URLPath}, a representation of a URL.
"""

from typing import cast
from urllib.parse import quote as urlquote, unquote as urlunquote, urlunsplit

from hyperlink import URL as _URL

_allascii = b"".join([chr(x).encode("ascii") for x in range(1, 128)])

def _rereconstituter(name):
    """
    Attriute declaration to preserve mutability on L{URLPath}.

@param name: a public attribute name
    @type name: native L{str}

@return: a descriptor which retrieves the private version of the attribute
        on get and calls rerealize on set.
    """
    privateName = "_" + name
    return property(
        lambda self: getattr(self, privateName),
        lambda self, value: (
            setattr(
                self,
                privateName,
                value if isinstance(value, bytes) else value.encode("charmap"),
            )
            or self._reconstitute()
        ),
    )

class URLPath:
    """
    A representation of a URL.

@ivar scheme: The scheme of the URL (e.g. 'http').
    @type scheme: L{bytes}

@ivar netloc: The network location ("host").
    @type netloc: L{bytes}

@ivar path: The path on the network location.
    @type path: L{bytes}

@ivar query: The query argument (the portion after ?  in the URL).
    @type query: L{bytes}

@ivar fragment: The page fragment (the portion after # in the URL).
    @type fragment: L{bytes}
    """

def __init__(
        self, scheme=b"", netloc=b"localhost", path=b"", query=b"", fragment=b""
    ):
        self._scheme = scheme or b"http"
        self._netloc = netloc
        self._path = path or b"/"
        self._query = query
        self._fragment = fragment
        self._reconstitute()

def _reconstitute(self):
        """
        Reconstitute this L{URLPath} from all its given attributes.
        """
        urltext = urlquote(
            urlunsplit(
                (self._scheme, self._netloc, self._path, self._query, self._fragment)
            ),
            safe=_allascii,
        )
        self._url = _URL.fromText(urltext.encode("ascii").decode("ascii"))

scheme = _rereconstituter("scheme")
    netloc = _rereconstituter("netloc")
    path = _rereconstituter("path")
    query = _rereconstituter("query")
    fragment = _rereconstituter("fragment")

@classmethod
    def _fromURL(cls, urlInstance):
        """
        Reconstruct all the public instance variables of this L{URLPath} from
        its underlying L{_URL}.

@param urlInstance: the object to base this L{URLPath} on.
        @type urlInstance: L{_URL}

@return: a new L{URLPath}
        """
        self = cls.__new__(cls)
        self._url = urlInstance.replace(path=urlInstance.path or [""])
        self._scheme = self._url.scheme.encode("ascii")
        self._netloc = self._url.authority().encode("ascii")
        self._path = (
            _URL(path=self._url.path, rooted=True).asURI().asText().encode("ascii")
        )
        self._query = (_URL(query=self._url.query).asURI().asText().encode("ascii"))[1:]
        self._fragment = self._url.fragment.encode("ascii")
        return self

def pathList(self, unquote=False, copy=True):
        """
        Split this URL's path into its components.

@param unquote: whether to remove %-encoding from the returned strings.

@param copy: (ignored, do not use)

@return: The components of C{self.path}
        @rtype: L{list} of L{bytes}
        """
        segments = self._url.path
        mapper = lambda x: x.encode("ascii")
        if unquote:
            mapper = lambda x, m=mapper: m(urlunquote(x))
        return [b""] + [mapper(segment) for segment in segments]

@classmethod
    def fromString(klass, url):
        """
        Make a L{URLPath} from a L{str} or L{unicode}.

@param url: A L{str} representation of a URL.
        @type url: L{str} or L{unicode}.

@return: a new L{URLPath} derived from the given string.
        @rtype: L{URLPath}
        """
        if not isinstance(url, str):
            raise ValueError("'url' must be a str")
        return klass._fromURL(_URL.fromText(url))

@classmethod
    def fromBytes(klass, url):
        """
        Make a L{URLPath} from a L{bytes}.

@param url: A L{bytes} representation of a URL.
        @type url: L{bytes}

@return: a new L{URLPath} derived from the given L{bytes}.
        @rtype: L{URLPath}

@since: 15.4
        """
        if not isinstance(url, bytes):
            raise ValueError("'url' must be bytes")
        quoted = urlquote(url, safe=_allascii)
        return klass.fromString(quoted)

@classmethod
    def fromRequest(klass, request):
        """
        Make a L{URLPath} from a L{twisted.web.http.Request}.

@param request: A L{twisted.web.http.Request} to make the L{URLPath}
            from.

@return: a new L{URLPath} derived from the given request.
        @rtype: L{URLPath}
        """
        return klass.fromBytes(request.prePathURL())

def _mod(self, newURL, keepQuery):
        """
        Return a modified copy of C{self} using C{newURL}, keeping the query
        string if C{keepQuery} is C{True}.

@param newURL: a L{URL} to derive a new L{URLPath} from
        @type newURL: L{URL}

@param keepQuery: if C{True}, preserve the query parameters from
            C{self} on the new L{URLPath}; if C{False}, give the new L{URLPath}
            no query parameters.
        @type keepQuery: L{bool}

@return: a new L{URLPath}
        """
        return self._fromURL(
            newURL.replace(fragment="", query=self._url.query if keepQuery else ())
        )

def sibling(self, path, keepQuery=False):
        """
        Get the sibling of the current L{URLPath}.  A sibling is a file which
        is in the same directory as the current file.

@param path: The path of the sibling.
        @type path: L{bytes}

@param keepQuery: Whether to keep the query parameters on the returned
            L{URLPath}.
        @type keepQuery: L{bool}

@return: a new L{URLPath}
        """
        return self._mod(self._url.sibling(path.decode("ascii")), keepQuery)

def child(self, path, keepQuery=False):
        """
        Get the child of this L{URLPath}.

@param path: The path of the child.
        @type path: L{bytes}

@param keepQuery: Whether to keep the query parameters on the returned
            L{URLPath}.
        @type keepQuery: L{bool}

@return: a new L{URLPath}
        """
        return self._mod(self._url.child(path.decode("ascii")), keepQuery)

def parent(self, keepQuery=False):
        """
        Get the parent directory of this L{URLPath}.

@param keepQuery: Whether to keep the query parameters on the returned
            L{URLPath}.
        @type keepQuery: L{bool}

@return: a new L{URLPath}
        """
        return self._mod(self._url.click(".."), keepQuery)

def here(self, keepQuery=False):
        """
        Get the current directory of this L{URLPath}.

@param keepQuery: Whether to keep the query parameters on the returned
            L{URLPath}.
        @type keepQuery: L{bool}

@return: a new L{URLPath}
        """
        return self._mod(self._url.click("."), keepQuery)

def click(self, st):
        """
        Return a path which is the URL where a browser would presumably take
        you if you clicked on a link with an HREF as given.

@param st: A relative URL, to be interpreted relative to C{self} as the
            base URL.
        @type st: L{bytes}

@return: a new L{URLPath}
        """
        return self._fromURL(self._url.click(st.decode("ascii")))

def __str__(self) -> str:
        """
        The L{str} of a L{URLPath} is its URL text.
        """
        return cast(str, self._url.asURI().asText())

def __repr__(self) -> str:
        """
        The L{repr} of a L{URLPath} is an eval-able expression which will
        construct a similar L{URLPath}.
        """
        return "URLPath(scheme={!r}, netloc={!r}, path={!r}, query={!r}, fragment={!r})".format(
            self.scheme,
            self.netloc,
            self.path,
            self.query,
            self.fragment,
        )

cmd: