Pyjoyment 0.1.0__py3-none-any.whl

Pyjo/Upload.py

@@ -0,0 +1,139 @@
+"""
+Pyjo.Upload - Upload
+====================
+::
+
+    from Pyjo.Upload import Upload
+
+    upload = Upload()
+    print(upload.filename)
+    upload.move_to('/home/sri/foo.txt')
+
+    # Or import the module, as in Google Python Style Guide
+
+    import Pyjo.Upload
+
+    upload = Pyjo.Upload.new()
+    print(upload.filename)
+    upload.move_to('/home/sri/foo.txt')
+
+:mod:`Pyjo.Upload` is a container for uploaded files.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojo::Upload <https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojo/Upload.pm>`_
+of Mojolicious 9.49.
+"""
+
+import Pyjo.Asset
+import Pyjo.Base
+import Pyjo.Headers
+
+import builtins
+
+from typing import Self
+
+
+type Anything = builtins.object
+
+
+class Pyjo_Upload(Pyjo.Base.object):
+    """
+    :mod:`Pyjo.Upload` inherits all methods from :mod:`Pyjo.Base` and
+    implements the following new ones.
+    """
+
+    def __init__(
+        self,
+        *,
+        asset: Pyjo.Asset.object | None = None,
+        filename: str | None = None,
+        headers: Pyjo.Headers.object | None = None,
+        name: str | None = None,
+    ) -> None:
+        """::
+
+            upload = Pyjo.Upload.new()
+            upload = Pyjo.Upload.new(name='foo', filename='foo.txt', asset=Pyjo.Asset.Memory.new())
+
+        Construct a new :mod:`Pyjo.Upload` object.
+        """
+        self.asset = asset
+        """::
+
+            asset = upload.asset
+            upload.asset = Pyjo.Asset.File.new()
+
+        Asset containing the uploaded data, usually a :mod:`Pyjo.Asset.File`
+        or :mod:`Pyjo.Asset.Memory` object.
+        """
+
+        self.filename = filename
+        """::
+
+            filename = upload.filename
+            upload.filename = 'foo.txt'
+
+        Name of the uploaded file.
+        """
+
+        self.headers = headers
+        """::
+
+            headers = upload.headers
+            upload.headers = Pyjo.Headers.new()
+
+        Headers for upload, usually a :mod:`Pyjo.Headers` object.
+        """
+
+        self.name = name
+        """::
+
+            name = upload.name
+            upload.name = 'foo'
+
+        Name of the upload.
+        """
+
+    def move_to(self, to: Anything) -> Self:
+        """::
+
+            upload = upload.move_to('/home/sri/foo.txt')
+
+        Move uploaded data into a specific file.
+        """
+        self._asset().move_to(to)
+        return self
+
+    @property
+    def size(self) -> int:
+        """::
+
+            size = upload.size
+
+        Size of uploaded data in bytes.
+        """
+        return self._asset().size
+
+    def slurp(self) -> bytes:
+        """::
+
+            content = upload.slurp()
+
+        Read all uploaded data at once.
+        """
+        return self._asset().slurp()
+
+    # The asset, which an upload without one does not have, as in Mojo
+    def _asset(self) -> Pyjo.Asset.object:
+        if (asset := self.asset) is None:
+            raise AttributeError("'NoneType' object has no attribute 'slurp'")
+        return asset
+
+
+new = Pyjo_Upload.new
+object = Pyjo_Upload
+Upload = Pyjo_Upload

Pyjo/UserAgent/CookieJar.py

@@ -0,0 +1,391 @@
+"""
+Pyjo.UserAgent.CookieJar - Cookie jar for HTTP user agents
+==========================================================
+::
+
+    import Pyjo.Cookie.Response
+
+    from Pyjo.UserAgent.CookieJar import CookieJar
+
+    # Add response cookies
+    jar = CookieJar()
+    jar.add(
+        Pyjo.Cookie.Response.new(
+            name='foo',
+            value='bar',
+            domain='localhost',
+            path='/test',
+        )
+    )
+
+    # Or import the module, as in Google Python Style Guide
+
+    import Pyjo.Cookie.Response
+    import Pyjo.URL
+    import Pyjo.UserAgent.CookieJar
+
+    # Add response cookies
+    jar = Pyjo.UserAgent.CookieJar.new()
+    jar.add(
+        Pyjo.Cookie.Response.new(
+            name='foo',
+            value='bar',
+            domain='localhost',
+            path='/test',
+        )
+    )
+
+    # Find request cookies
+    for cookie in jar.find(Pyjo.URL.new('http://localhost/test')):
+        print(cookie.name)
+        print(cookie.value)
+
+:mod:`Pyjo.UserAgent.CookieJar` is a minimalistic and relaxed cookie jar used
+by :mod:`Pyjo.UserAgent`, based on :rfc:`6265`.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojo::UserAgent::CookieJar <https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojo/UserAgent/CookieJar.pm>`_
+of Mojolicious 9.49.
+
+Classes
+-------
+"""
+
+import Pyjo.Base
+import Pyjo.Cookie.Request
+import Pyjo.Cookie.Response
+import Pyjo.File
+import Pyjo.Path
+import Pyjo.Transaction
+import Pyjo.URL
+
+from Pyjo.String.Unicode import split
+
+import builtins
+import os
+import re
+import time
+
+from collections.abc import Callable
+from typing import Any, Self
+
+
+type Anything = builtins.object
+
+
+# Unlike Mojolicious: the file says that Pyjoyment generated it
+COMMENT = '# Netscape HTTP Cookie File\n# This file was generated by Pyjoyment! Edit at your own risk.\n\n'
+
+
+class Pyjo_UserAgent_CookieJar(Pyjo.Base.object):
+    """
+    :mod:`Pyjo.UserAgent.CookieJar` inherits all methods from :mod:`Pyjo.Base`
+    and implements the following new ones.
+    """
+
+    def __init__(
+        self,
+        *,
+        file: str | os.PathLike[str] | None = None,
+        ignore: Callable[[Pyjo.Cookie.Response.object], Any] | None = None,
+        max_cookie_size: int = 4096,
+    ) -> None:
+        """::
+
+            jar = Pyjo.UserAgent.CookieJar.new()
+            jar = Pyjo.UserAgent.CookieJar.new(file='cookies.txt')
+
+        Construct a new :mod:`Pyjo.UserAgent.CookieJar` object.
+        """
+        self.file = file
+        """::
+
+            file = jar.file
+            jar.file = '/home/sri/cookies.txt'
+
+        File to :meth:`load` cookies from and :meth:`save` cookies to in
+        Netscape format. ::
+
+            # Save cookies to file
+            jar.file = 'cookies.txt'
+            jar.save()
+
+            # Empty cookie jar and load cookies from file
+            jar.file = 'cookies.txt'
+            jar.empty().load()
+        """
+
+        self.ignore = ignore
+        """::
+
+            ignore = jar.ignore
+            jar.ignore = lambda cookie: ...
+
+        A callback used to decide if a cookie should be ignored by
+        :meth:`collect`. ::
+
+            # Ignore all cookies
+            jar.ignore = lambda cookie: True
+
+            # Ignore cookies for domains "com", "net" and "org"
+            jar.ignore = lambda cookie: cookie.domain in ('com', 'net', 'org')
+        """
+
+        self.max_cookie_size = max_cookie_size
+        """::
+
+            size = jar.max_cookie_size
+            jar.max_cookie_size = 4096
+
+        Maximum cookie size in bytes, defaults to ``4096`` (4KiB).
+        """
+
+        self._jar: dict[str, list[Pyjo.Cookie.Response.object]] = {}
+
+    def add(self, *cookies: Pyjo.Cookie.Response.object) -> Self:
+        """::
+
+            jar = jar.add(*cookies)
+
+        Add multiple :mod:`Pyjo.Cookie.Response` objects to the jar.
+        """
+        size = self.max_cookie_size
+        for cookie in cookies:
+            # Convert max age to expires
+            if (age := _number(cookie.max_age)) is not None:
+                cookie.expires = 0 if age <= 0 else age + int(time.time())
+
+            # Check cookie size
+            if len(cookie.value or '') > size:
+                continue
+
+            # Replace cookie
+            if not (domain := (cookie.domain or '').lower()):
+                continue
+            if not (path := cookie.path):
+                continue
+            if not len(name := cookie.name or ''):
+                continue
+            jar = self._jar.setdefault(domain, [])
+            jar[:] = [*(c for c in jar if _compare(c, path, name, domain)), cookie]
+
+        return self
+
+    def all(self) -> list[Pyjo.Cookie.Response.object]:
+        """::
+
+            cookies = jar.all()
+
+        Return all :mod:`Pyjo.Cookie.Response` objects that are currently stored
+        in the jar. ::
+
+            # Names of all cookies
+            for cookie in jar.all():
+                print(cookie.name)
+        """
+        jar = self._jar
+        return [cookie for domain in sorted(jar) for cookie in jar[domain]]
+
+    def collect(self, tx: Pyjo.Transaction.object) -> None:
+        """::
+
+            jar.collect(Pyjo.Transaction.HTTP.new())
+
+        Collect response cookies from transaction.
+        """
+        url = tx.req.url
+        for cookie in tx.res.cookies():
+            # Validate domain
+            host = (url.ihost or '').lower()
+            if not cookie.domain:
+                cookie.domain, cookie.host_only = host, True
+            domain = cookie.domain.lower()
+            if (ignore := self.ignore) and ignore(cookie):
+                continue
+            if host != domain and (not host.endswith(f'.{domain}') or re.search(r'\.\d+$', host)):
+                continue
+
+            # Validate path
+            path = Pyjo.Path.new(cookie.path if cookie.path is not None else url.path.to_dir().to_abs_str())
+            path.trailing_slash = False
+            if not _path(path := path.to_abs_str(), url.path.to_abs_str()):
+                continue
+            cookie.path = path
+            self.add(cookie)
+
+    def empty(self) -> Self:
+        """::
+
+            jar = jar.empty()
+
+        Empty the jar.
+        """
+        self._jar = {}
+        return self
+
+    def find(self, url: Pyjo.URL.object) -> list[Pyjo.Cookie.Request.object]:
+        """::
+
+            cookies = jar.find(Pyjo.URL.new())
+
+        Find :mod:`Pyjo.Cookie.Request` objects in the jar for
+        :mod:`Pyjo.URL` object. ::
+
+            # Names of all cookies found
+            for cookie in jar.find(Pyjo.URL.new('http://example.com/foo')):
+                print(cookie.name)
+        """
+        found: list[Pyjo.Cookie.Request.object] = []
+        domain = host = (url.ihost or '').lower()
+        path = url.path.to_abs_str()
+        while domain:
+            if (old := self._jar.get(domain)) is not None:
+                # Grab cookies
+                new = self._jar[domain] = []
+                for cookie in old:
+                    if cookie.host_only and host != cookie.domain:
+                        continue
+
+                    # Check if cookie has expired
+                    if (expires := cookie.expires) is not None and int(time.time()) > expires:
+                        continue
+                    new.append(cookie)
+
+                    # Taste cookie
+                    if cookie.secure and url.protocol != 'https':
+                        continue
+                    if not _path(cookie.path or '', path):
+                        continue
+                    found.append(Pyjo.Cookie.Request.new(name=cookie.name, value=cookie.value))
+
+            # Remove another part
+            domain = re.sub(r'^[^.]*\.*', '', domain, count=1)
+
+        return found
+
+    def load(self) -> Self:
+        """::
+
+            jar = jar.load()
+
+        Load cookies from :attr:`file`.
+        """
+        if not (file := self.file) or not os.access(file, os.R_OK):
+            return self
+
+        # Unlike Mojolicious: the file is UTF-8, where Mojo reads and writes characters as they are, and warns about
+        # wide characters
+        content = str(Pyjo.File.path(file).slurp('UTF-8'))
+
+        # Unlike Mojolicious: a line may end with CRLF, as curl and http.cookiejar write the file on Windows, where Mojo
+        # keeps the carriage return in the value of the cookie
+        for line in split(r'\r?\n', content):
+            # Prefix used by curl for HttpOnly cookies
+            line = line or ''
+            httponly = line.startswith('#HttpOnly_')
+            line = line.removeprefix('#HttpOnly_')
+            if line.startswith('#'):
+                continue
+
+            # Unlike Mojolicious: the empty value of a cookie at the end of the line is a field, where Mojo's split
+            # leaves it out and the cookie with it
+            values = [value or '' for value in split('\t', line, -1)]
+            if len(values) != 7:
+                continue
+
+            self.add(
+                Pyjo.Cookie.Response.new(
+                    domain=values[0].removeprefix('.'),
+                    host_only=values[1] == 'FALSE',
+                    path=values[2],
+                    secure=values[3] != 'FALSE',
+                    expires=None if values[4] == '0' else _number(values[4]),
+                    name=values[5],
+                    value=values[6],
+                    httponly=httponly,
+                )
+            )
+
+        return self
+
+    def prepare(self, tx: Pyjo.Transaction.object) -> None:
+        """::
+
+            jar.prepare(Pyjo.Transaction.HTTP.new())
+
+        Prepare request cookies for transaction.
+        """
+        if not self._jar:
+            return
+        req = tx.req
+        req.cookies(*self.find(req.url))
+
+    def save(self) -> Self:
+        """::
+
+            jar = jar.save()
+
+        Save cookies to :attr:`file`.
+        """
+        if not (file := self.file):
+            return self
+
+        final = Pyjo.File.path(file)
+        tmp = Pyjo.File.path(f'{os.fspath(file)}.{os.getpid()}')
+        tmp.spew(COMMENT + self.to_str(), 'UTF-8').move_to(final)
+
+        return self
+
+    def to_str(self) -> str:
+        """::
+
+            string = jar.to_str()
+
+        Stringify cookies in Netscape format.
+        """
+        lines: list[str] = []
+        for cookie in self.all():
+            expires = cookie.expires if cookie.expires is not None else 0
+            # Unlike Mojolicious: the domain of a cookie for subdomains starts with a dot, as curl and the
+            # MozillaCookieJar of http.cookiejar write it and the latter needs it, where Mojo leaves the dot out
+            domain = cookie.domain or ''
+            line = [
+                domain if cookie.host_only else f'.{domain}',
+                'FALSE' if cookie.host_only else 'TRUE',
+                cookie.path or '',
+                'TRUE' if cookie.secure else 'FALSE',
+                str(int(expires) if float(expires).is_integer() else expires),
+                cookie.name or '',
+                cookie.value or '',
+            ]
+            lines.append('\t'.join(line))
+
+        return '\n'.join([*lines, ''])
+
+
+def _compare(cookie: Pyjo.Cookie.Response.object, path: str, name: str, domain: str) -> bool:
+    return cookie.path != path or cookie.name != name or cookie.domain != domain
+
+
+# Not in Mojolicious: a number as Perl's looks_like_number takes it, as the value of an integer or a float
+def _number(value: Anything) -> int | float | None:
+    if value is None or isinstance(value, bool):
+        return None
+    try:
+        number = float(str(value))
+    except ValueError:
+        return None
+    return int(number) if number.is_integer() else number
+
+
+def _path(path1: str, path2: str) -> bool:
+    return path1 == '/' or path1 == path2 or path2.startswith(f'{path1}/')
+
+
+new = Pyjo_UserAgent_CookieJar.new
+object = Pyjo_UserAgent_CookieJar
+CookieJar = Pyjo_UserAgent_CookieJar

Pyjo/UserAgent/Proxy.py

@@ -0,0 +1,138 @@
+"""
+Pyjo.UserAgent.Proxy - User agent proxy manager
+===============================================
+::
+
+    from Pyjo.UserAgent.Proxy import Proxy
+
+    proxy = Proxy()
+    proxy.detect()
+    print(proxy.http)
+
+    # Or import the module, as in Google Python Style Guide
+
+    import Pyjo.UserAgent.Proxy
+
+    proxy = Pyjo.UserAgent.Proxy.new()
+    proxy.detect()
+    print(proxy.http)
+
+:mod:`Pyjo.UserAgent.Proxy` manages proxy servers for :mod:`Pyjo.UserAgent`.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojo::UserAgent::Proxy <https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojo/UserAgent/Proxy.pm>`_
+of Mojolicious 9.49.
+
+Classes
+-------
+"""
+
+import Pyjo.Base
+import Pyjo.Transaction
+import Pyjo.URL
+
+from Pyjo.String.Unicode import split
+
+import os
+
+from typing import Self
+
+
+class Pyjo_UserAgent_Proxy(Pyjo.Base.object):
+    """
+    :mod:`Pyjo.UserAgent.Proxy` inherits all methods from :mod:`Pyjo.Base` and
+    implements the following new ones.
+    """
+
+    def __init__(self, *, http: str | None = None, https: str | None = None, no: list[str] | None = None) -> None:
+        """::
+
+            proxy = Pyjo.UserAgent.Proxy.new()
+            proxy = Pyjo.UserAgent.Proxy.new(http='http://127.0.0.1:8080')
+
+        Construct a new :mod:`Pyjo.UserAgent.Proxy` object.
+        """
+        self.http = http
+        """::
+
+            http = proxy.http
+            proxy.http = 'socks://sri:secret@127.0.0.1:8080'
+
+        Proxy server to use for HTTP and WebSocket requests.
+        """
+
+        self.https = https
+        """::
+
+            https = proxy.https
+            proxy.https = 'http://sri:secret@127.0.0.1:8080'
+
+        Proxy server to use for HTTPS and WebSocket requests.
+        """
+
+        # Renamed from Mojolicious: not, a keyword of Python, as the environment variable NO_PROXY names it
+        self.no = no
+        """::
+
+            no = proxy.no
+            proxy.no = ['localhost', 'intranet.mojolicious.org']
+
+        Domains that don't require a proxy server to be used.
+        """
+
+    def detect(self) -> Self:
+        """::
+
+            proxy = proxy.detect()
+
+        Check environment variables ``HTTP_PROXY``, ``http_proxy``,
+        ``HTTPS_PROXY``, ``https_proxy``, ``NO_PROXY`` and ``no_proxy`` for proxy
+        information. Automatic proxy detection can be enabled with the
+        ``PYJO_PROXY`` environment variable.
+        """
+        env = os.environ
+        self.http = env.get('HTTP_PROXY') or env.get('http_proxy')
+        self.https = env.get('HTTPS_PROXY') or env.get('https_proxy')
+        self.no = [domain or '' for domain in split(',', env.get('NO_PROXY') or env.get('no_proxy') or '')]
+        return self
+
+    def is_needed(self, domain: str) -> bool:
+        """::
+
+            boolean = proxy.is_needed('intranet.example.com')
+
+        Check if request for domain would use a proxy server.
+        """
+        return not any(domain.endswith(no) for no in self.no or [])
+
+    def prepare(self, tx: Pyjo.Transaction.object) -> None:
+        """::
+
+            proxy.prepare(Pyjo.Transaction.HTTP.new())
+
+        Prepare proxy server information for transaction.
+        """
+        if os.environ.get('PYJO_PROXY') not in (None, '', '0'):
+            self.detect()
+        req = tx.req
+        url = req.url
+        if not self.is_needed(url.host or ''):
+            return
+
+        # HTTP proxy
+        proto = url.protocol
+        if (http := self.http) and proto == 'http':
+            req.proxy = Pyjo.URL.new(http)
+
+        # HTTPS proxy
+        if (https := self.https) and proto == 'https':
+            req.proxy = Pyjo.URL.new(https)
+
+
+new = Pyjo_UserAgent_Proxy.new
+object = Pyjo_UserAgent_Proxy
+Proxy = Pyjo_UserAgent_Proxy