Pyjoyment 0.1.0__py3-none-any.whl

Pyjoyment/Command/eval.py

@@ -0,0 +1,128 @@
+"""
+Pyjoyment.Command.eval - Eval command
+=====================================
+::
+
+    Usage: APPLICATION eval [OPTIONS] CODE
+
+      ./myapp.py eval 'print(app.ua.get("/").result.body)'
+      ./myapp.py eval 'print(*sorted(app.renderer.helpers), sep="\\n")'
+      ./myapp.py eval -v 'app.home'
+      ./myapp.py eval -V 'app.renderer.paths'
+
+    Options:
+      -h, --help                Show this summary of available options
+          --home <path>         Path to home directory of your application,
+                                defaults to the value of PYJO_HOME or
+                                auto-detection
+          --log-format <name>   Format of log messages, "text" or "json",
+                                defaults to the value of PYJO_LOG_FORMAT or
+                                "text"
+      -m, --mode <name>         Operating mode for your application, defaults to
+                                the value of PYJO_MODE or "development"
+      -v, --verbose             Print return value to sys.stdout
+      -V                        Print returned data structure to sys.stdout
+
+:mod:`Pyjoyment.Command.eval` runs code against applications. The code
+is Python, with the application as ``app``, and its result is the value of its
+last expression. If the result is a promise (then-able), it will wait until
+the promise is fulfilled or rejected and the result is returned.
+
+This is a core command, that means it is always enabled and its code a good
+example for learning to build new commands, you're welcome to fork it.
+
+See :mod:`Pyjoyment.Commands` for a list of commands that are available by
+default.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojolicious::Command::eval
+<https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojolicious/Command/eval.pm>`_ of Mojolicious 9.49.
+
+Classes
+-------
+"""
+
+import Pyjo.Exception
+import Pyjo.Promise
+import Pyjoyment.Command
+
+from Pyjo.Util import extract_usage, getopt
+
+import ast
+
+from typing import Any
+
+
+class Pyjoyment_Command_eval(Pyjoyment.Command.object):
+    """
+    :mod:`Pyjoyment.Command.eval` inherits all attributes and methods from
+    :mod:`Pyjoyment.Command` and implements the following new ones.
+    """
+
+    description = 'Run code against application'
+    """::
+
+        description = eval.description
+        eval.description = 'Foo'
+
+    Short description of this command, used for the command list.
+    """
+
+    usage = extract_usage()
+    """::
+
+        usage = eval.usage
+        eval.usage = 'Foo'
+
+    Usage information for this command, used for the help screen.
+    """
+
+    def run(self, *args: str) -> Any:
+        """::
+
+            eval.run(*sys.argv[1:])
+
+        Run this command.
+        """
+        arguments = list(args)
+        if not (opts := getopt(arguments, {'v|verbose': None, 'V': None})):
+            raise Pyjo.Exception.new(self.usage)
+        code = arguments.pop(0) if arguments else ''
+
+        # Run code against application
+        app = self.app
+        # Unlike Mojolicious: Python code, whose value is the one of its last expression, as the value of Perl code is
+        # the one of its last statement
+        result = _eval(code, {'__name__': '__main__', 'app': app})
+
+        # Handle promises
+        values: list[Any] = []
+        errors: list[Any] = []
+        Pyjo.Promise.resolve(result).then(values.append, errors.append).wait()
+        if errors:
+            raise errors[0] if isinstance(errors[0], BaseException) else Pyjo.Exception.new(str(errors[0]))
+        result = values[0] if values else None
+        if result is None or not (opts.verbose or opts.V):
+            return result
+        if opts.V:
+            print(app.dumper(result), end='')
+        else:
+            print(result)
+        return None
+
+
+def _eval(code: str, namespace: dict[str, Any]) -> Any:
+    tree = ast.parse(code, '-e')
+    last = tree.body.pop() if tree.body and isinstance(tree.body[-1], ast.Expr) else None
+    exec(compile(tree, '-e', 'exec'), namespace)
+    if not isinstance(last, ast.Expr):
+        return None
+    return eval(compile(ast.Expression(last.value), '-e', 'eval'), namespace)
+
+
+new = Pyjoyment_Command_eval.new
+object = Pyjoyment_Command_eval

Pyjoyment/Command/fastcgi.py

@@ -0,0 +1,99 @@
+"""
+Pyjoyment.Command.fastcgi - FastCGI command
+===========================================
+::
+
+    Usage: APPLICATION fastcgi [OPTIONS]
+
+      ./myapp.py fastcgi
+
+    Options:
+      -h, --help                Show this summary of available options
+          --home <path>         Path to home directory of your application,
+                                defaults to the value of PYJO_HOME or
+                                auto-detection
+          --log-format <name>   Format of log messages, "text" or "json",
+                                defaults to the value of PYJO_LOG_FORMAT or
+                                "text"
+      -m, --mode <name>         Operating mode for your application, defaults to
+                                the value of PYJO_MODE or "development"
+
+:mod:`Pyjoyment.Command.fastcgi` starts applications that a web server starts
+as FastCGI applications, as Apache with ``mod_fcgid`` and lighttpd do: it
+serves the listen socket that the web server gives the application as the
+file descriptor ``0``, with :mod:`Pyjo.Server.Daemon` and
+:mod:`Pyjo.Server.FastCGI`, and is detected by :mod:`Pyjoyment.Commands`
+when the file descriptor ``0`` is such a socket. A FastCGI application that
+listens on a socket of its own, which the web server connects to, is started
+with the commands ``daemon`` and ``prefork`` and a listen location
+``fcgi://`` or ``fcgi+unix://``.
+
+This is a core command, that means it is always enabled and its code a good
+example for learning to build new commands, you're welcome to fork it.
+
+See :mod:`Pyjoyment.Commands` for a list of commands that are available by
+default.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+It has no counterpart in Mojolicious; :mod:`Pyjoyment.Command.cgi` is the
+counterpart of `Mojolicious::Command::cgi
+<https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojolicious/Command/cgi.pm>`_.
+
+Classes
+-------
+"""
+
+import Pyjo.Exception
+import Pyjo.Server.Daemon
+import Pyjoyment.Command
+
+from Pyjo.Util import extract_usage, getopt
+
+from typing import Any
+
+
+class Pyjoyment_Command_fastcgi(Pyjoyment.Command.object):
+    """
+    :mod:`Pyjoyment.Command.fastcgi` inherits all attributes and methods from
+    :mod:`Pyjoyment.Command` and implements the following new ones.
+    """
+
+    description = 'Start application with FastCGI of the web server'
+    """::
+
+        description = fastcgi.description
+        fastcgi.description = 'Foo'
+
+    Short description of this command, used for the command list.
+    """
+
+    usage = extract_usage()
+    """::
+
+        usage = fastcgi.usage
+        fastcgi.usage = 'Foo'
+
+    Usage information for this command, used for the help screen.
+    """
+
+    def run(self, *args: str) -> Any:
+        """::
+
+            fastcgi.run(*sys.argv[1:])
+
+        Run this command.
+        """
+        arguments = list(args)
+        if not getopt(arguments, {}) or len(arguments):
+            raise Pyjo.Exception.new(self.usage)
+
+        # The listen socket of the web server, silent, as the web server does not read the output of the application
+        Pyjo.Server.Daemon.new(app=self.app, listen=['fcgi://*?fd=0'], silent=True).run()
+
+
+new = Pyjoyment_Command_fastcgi.new
+object = Pyjoyment_Command_fastcgi

Pyjoyment/Command/get.py

@@ -0,0 +1,305 @@
+"""
+Pyjoyment.Command.get - Get command
+===================================
+::
+
+    Usage: APPLICATION get [OPTIONS] URL [SELECTOR|JSON-POINTER] [COMMANDS]
+
+      ./myapp.py get /
+      ./myapp.py get -H 'Accept: text/html' /hello.html 'head > title' text
+      ./myapp.py get //sri:secr3t@/secrets.json /1/content
+      pyjo get mojolicious.org
+      pyjo get -v -r -o 25 -i 50 google.com
+      pyjo get -v -H 'Host: mojolicious.org' -H 'Accept: */*' mojolicious.org
+      pyjo get -u 'sri:s3cret' https://mojolicious.org
+      pyjo get mojolicious.org > example.html
+      pyjo get -M PUT mojolicious.org < example.html
+      pyjo get -f 'q=Mojolicious' -f 'size=5' https://metacpan.org/search
+      pyjo get -M POST -f 'upload=@example.html' mojolicious.org
+      pyjo get mojolicious.org 'head > title' text
+      pyjo get mojolicious.org .footer all
+      pyjo get mojolicious.org a attr href
+      pyjo get mojolicious.org '*' attr id
+      pyjo get mojolicious.org 'h1, h2, h3' 3 text
+      pyjo get https://pypi.org/pypi/Pyjoyment/json /info/version
+      pyjo get -H 'Host: example.com' http+unix://%2Ftmp%2Fmyapp.sock/index.html
+
+    Options:
+      -C, --charset <charset>              Charset of HTML/XML content, defaults
+                                           to auto-detection
+      -c, --content <content>              Content to send with request
+      -f, --form <name=value>              One or more form values and file
+                                           uploads
+      -H, --header <name:value>            One or more additional HTTP headers
+      -h, --help                           Show this summary of available options
+          --home <path>                    Path to home directory of your
+                                           application, defaults to the value of
+                                           PYJO_HOME or auto-detection
+      -i, --inactivity-timeout <seconds>   Inactivity timeout, defaults to the
+                                           value of PYJO_INACTIVITY_TIMEOUT or 40
+      -k, --insecure                       Do not require a valid TLS certificate
+                                           to access HTTPS sites
+          --log-format <name>              Format of log messages, "text" or
+                                           "json", defaults to the value of
+                                           PYJO_LOG_FORMAT or "text"
+      -M, --method <method>                HTTP method to use, defaults to "GET"
+      -m, --mode <name>                    Operating mode for your application,
+                                           defaults to the value of PYJO_MODE or
+                                           "development"
+      -o, --connect-timeout <seconds>      Connect timeout, defaults to the value
+                                           of PYJO_CONNECT_TIMEOUT or 10
+      -r, --redirect                       Follow up to 10 redirects
+      -S, --response-size <size>           Maximum response size in bytes,
+                                           defaults to 2147483648 (2GiB)
+      -u, --user <userinfo>                Alternate mechanism for specifying
+                                           colon-separated username and password
+      -v, --verbose                        Print request and response headers to
+                                           STDERR
+
+:mod:`Pyjoyment.Command.get` performs requests to remote hosts or local
+applications.
+
+This is a core command, that means it is always enabled and its code a good
+example for learning to build new commands, you're welcome to fork it.
+
+See :mod:`Pyjoyment.Commands` for a list of commands that are available by
+default.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojolicious::Command::get
+<https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojolicious/Command/get.pm>`_ of Mojolicious 9.49.
+
+Classes
+-------
+"""
+
+import Pyjo.Collection
+import Pyjo.DOM
+import Pyjo.Exception
+import Pyjo.IOLoop
+import Pyjo.JSON.Pointer
+import Pyjo.Message
+import Pyjo.URL
+import Pyjo.UserAgent
+import Pyjoyment.Command
+
+from Pyjo.JSON import j, to_json
+from Pyjo.Util import decode, extract_usage, getopt, warn
+
+import re
+import select
+import sys
+import weakref
+
+from typing import Any, cast
+
+
+class Pyjoyment_Command_get(Pyjoyment.Command.object):
+    """
+    :mod:`Pyjoyment.Command.get` inherits all attributes and methods from
+    :mod:`Pyjoyment.Command` and implements the following new ones.
+    """
+
+    description = 'Perform HTTP request'
+    """::
+
+        description = get.description
+        get.description = 'Foo'
+
+    Short description of this command, used for the command list.
+    """
+
+    usage = extract_usage()
+    """::
+
+        usage = get.usage
+        get.usage = 'Foo'
+
+    Usage information for this command, used for the help screen.
+    """
+
+    def run(self, *args: str) -> None:
+        """::
+
+            get.run(*sys.argv[1:])
+
+        Run this command.
+        """
+        # Data from STDIN
+        content = _stdin()
+
+        ua: Any = Pyjo.UserAgent.new(ioloop=Pyjo.IOLoop.singleton)
+        arguments = list(args)
+        form: dict[str, list[Any]] = {}
+        headers: list[str] = []
+        opts = getopt(
+            arguments,
+            {
+                'C|charset=s': None,
+                'c|content=s': None,
+                'f|form=s': lambda name, value: _form(form, value),
+                'H|header=s': headers,
+                'i|inactivity-timeout=i': lambda name, value: setattr(ua, 'inactivity_timeout', value),
+                'k|insecure': lambda name, value: setattr(ua, 'insecure', True),
+                'M|method=s': None,
+                'o|connect-timeout=i': lambda name, value: setattr(ua, 'connect_timeout', value),
+                'r|redirect': None,
+                'S|response-size=i': lambda name, value: setattr(ua, 'max_response_size', value),
+                'u|user=s': None,
+                'v|verbose': None,
+            },
+        )
+        if not opts:
+            raise Pyjo.Exception.new(self.usage)
+        if opts.content is not None:
+            content = opts.content
+        method: str = opts.method or 'GET'
+        redirect, verbose = opts.redirect, opts.verbose
+
+        # Left out from Mojolicious: decoding the arguments, which Python has as characters already
+        if not arguments:
+            raise Pyjo.Exception.new(self.usage)
+        url: Any = arguments.pop(0)
+        selector = arguments.pop(0) if arguments else None
+
+        # Parse header pairs
+        pairs = {m[1]: m[2] for header in headers if (m := re.match(r'^\s*([^:]+)\s*:\s*(.*)$', header))}
+
+        # Detect proxy for absolute URLs
+        if not url.startswith('/'):
+            ua.proxy.detect()
+        else:
+            ua.server.app = self.app
+        if opts.user:
+            url = Pyjo.URL.new(url).set(userinfo=opts.user)
+        if redirect:
+            ua.max_redirects = 10
+
+        buffer = bytearray()
+
+        @ua.on('start')
+        def start(ua: Any, tx: Any) -> None:
+            # Verbose
+            tx = weakref.proxy(tx)
+            if verbose:
+
+                @tx.res.content.on('body')
+                def body(content: Any) -> None:
+                    warn(_header(tx.req), _header(tx.res))
+
+            # Stream content (ignore redirects)
+            @tx.res.content.unsubscribe('read').on('read')
+            def read(content: Any, chunk: bytes) -> None:
+                if redirect and tx.res.is_redirect:
+                    return
+                if selector is not None:
+                    buffer.extend(chunk)
+                else:
+                    _write(chunk)
+
+        # Switch to verbose for HEAD requests
+        if method == 'HEAD':
+            verbose = True
+        if form:
+            tx = ua.start(ua.build_tx(method, url, pairs, form=form))
+        elif content is not None:
+            tx = ua.start(ua.build_tx(method, url, pairs, content))
+        else:
+            tx = ua.start(ua.build_tx(method, url, pairs))
+        res = tx.result
+
+        # JSON Pointer
+        if selector is None:
+            return None
+        if not selector or selector.startswith('/'):
+            return _json(bytes(buffer), selector)
+
+        # Selector
+        charset = opts.charset or res.content.charset or res.default_charset
+        return _select(bytes(buffer), selector, charset, *arguments)
+
+
+def _form(form: dict[str, list[Any]], value: str) -> None:
+    if m := re.match(r'^(.+)=(@?)(.+)$', value, re.S):
+        form.setdefault(m[1], []).append({'file': m[3]} if m[2] else m[3])
+
+
+def _header(msg: Pyjo.Message.object) -> str:
+    return msg.build_start_line().decode('latin-1') + msg.headers.to_str() + '\n\n'
+
+
+def _json(buffer: bytes, pointer: str) -> None:
+    if not (data := j(buffer)):
+        return
+    if (data := Pyjo.JSON.Pointer.new(data).get(pointer)) is None:
+        return
+    _say(to_json(cast(object, data)) if isinstance(data, (dict, list)) else data)
+
+
+def _say(*values: Any) -> None:
+    for value in values:
+        if value is not None and (text := str(value)):
+            print(text)
+
+
+def _select(buffer: bytes, selector: str, charset: str | None, *args: str) -> None:
+    arguments = list(args)
+
+    # Keep a strong reference to the root
+    text = (decode(charset, buffer) if charset else None) or buffer.decode('latin-1')
+    dom = Pyjo.DOM.new(text)
+    results: Any = dom.find(selector)
+
+    while arguments:
+        command = arguments.pop(0)
+
+        # Number
+        if re.fullmatch(r'\d+', command):
+            index = int(command)
+            results = Pyjo.Collection.c(*results[index : index + 1])
+            continue
+
+        # Text
+        if command == 'text':
+            return _say(*results.map('text').each())
+
+        # All text
+        if command == 'all':
+            return _say(*results.map('all_text').each())
+
+        # Attribute
+        if command == 'attr':
+            return _say(*results.map('attr', arguments[0] if arguments else '').each())
+
+        # Unknown
+        raise Pyjo.Exception.new(f'Unknown command "{command}".\n')
+
+    _say(*results.each())
+
+
+# Data from sys.stdin, unless it is a terminal or has nothing to read yet
+def _stdin() -> str | None:
+    try:
+        if sys.stdin.isatty() or not select.select([sys.stdin], [], [], 0)[0]:
+            return None
+    except (AttributeError, OSError, ValueError):
+        return None
+    return sys.stdin.read()
+
+
+# The bytes of the response, as Mojo prints them, after what sys.stdout has buffered
+def _write(chunk: bytes) -> None:
+    sys.stdout.flush()
+    if (out := getattr(sys.stdout, 'buffer', None)) is not None:
+        out.write(chunk)
+        out.flush()
+    else:
+        sys.stdout.write(chunk.decode('latin-1'))
+
+
+new = Pyjoyment_Command_get.new
+object = Pyjoyment_Command_get

Pyjoyment/Command/lambda.py

@@ -0,0 +1,117 @@
+"""
+Pyjoyment.Command.lambda - AWS Lambda command
+=============================================
+::
+
+    Usage: APPLICATION lambda [OPTIONS]
+
+      handler = app.start('lambda')
+
+    Options:
+      -h, --help                Show this summary of available options
+          --home <path>         Path to home directory of your application,
+                                defaults to the value of PYJO_HOME or
+                                auto-detection
+          --log-format <name>   Format of log messages, "text" or "json",
+                                defaults to the value of PYJO_LOG_FORMAT or
+                                "text"
+      -m, --mode <name>         Operating mode for your application, defaults to
+                                the value of PYJO_MODE or "development"
+
+:mod:`Pyjoyment.Command.lambda` starts applications with the
+:mod:`Pyjo.Server.Lambda` backend: it returns the handler of an event
+function of AWS Lambda, which a script keeps for the runtime that imports it.
+The script of an application that ends with ``handler = app.start()``, as
+``myapp.py`` with the handler ``myapp.handler``, runs this command in the
+runtime of AWS Lambda, which has the ``AWS_LAMBDA_RUNTIME_API`` environment
+variable, and the command of its arguments otherwise.
+
+The script that runs as the main program with that variable, as the
+``bootstrap`` of a custom runtime or the command of an image, is the runtime
+itself: the command runs the application for the invocations of the Runtime
+API with :meth:`Pyjo.Server.Lambda.Pyjo_Server_Lambda.run_runtime`, until the
+process ends, where a runtime that imports the script takes its handler. ::
+
+    #!/bin/sh
+    # The bootstrap of a custom runtime, as provided.al2023
+    exec python3 "$LAMBDA_TASK_ROOT/myapp.py"
+
+This is a core command, that means it is always enabled and its code a good
+example for learning to build new commands, you're welcome to fork it.
+
+See :mod:`Pyjoyment.Commands` for a list of commands that are available by
+default.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Classes
+-------
+"""
+
+# Not in Mojolicious: the command of AWS Lambda, as Pyjoyment.Command.wsgi is the one of WSGI; its module has the name
+# of a keyword of Python, which only the loader of the commands imports
+
+import Pyjo.Server.Lambda
+import Pyjoyment.Command
+
+from Pyjo.Util import extract_usage
+
+import inspect
+import os
+
+from typing import Any
+
+
+class Pyjoyment_Command_lambda(Pyjoyment.Command.object):
+    """
+    :mod:`Pyjoyment.Command.lambda` inherits all attributes and methods from
+    :mod:`Pyjoyment.Command` and implements the following new ones.
+    """
+
+    description = 'Start application with AWS Lambda'
+    """::
+
+        description = command.description
+        command.description = 'Foo'
+
+    Short description of this command, used for the command list.
+    """
+
+    usage = extract_usage()
+    """::
+
+        usage = command.usage
+        command.usage = 'Foo'
+
+    Usage information for this command, used for the help screen.
+    """
+
+    def run(self, *args: str) -> Any:
+        """::
+
+            handler = command.run()
+
+        Run this command.
+        """
+        server = Pyjo.Server.Lambda.new(app=self.app)
+
+        # The script of the application as the runtime, where a runtime that imports it takes its handler
+        if os.environ.get('AWS_LAMBDA_RUNTIME_API') and _is_main():
+            return server.run_runtime()
+        return server.to_lambda_app()
+
+
+# The module that starts the application is the main program, outside of the frames of Pyjoyment, where it is a module
+# that a runtime imports otherwise
+def _is_main() -> bool:
+    frame = inspect.currentframe()
+    while frame is not None and str(frame.f_globals.get('__name__', '')).split('.')[0] in ('Pyjo', 'Pyjoyment'):
+        frame = frame.f_back
+    return frame is not None and frame.f_globals.get('__name__') == '__main__'
+
+
+new = Pyjoyment_Command_lambda.new
+object = Pyjoyment_Command_lambda