rapydscript-ns 0.9.2 → 0.9.3

package/src/lib/http/client.pyj

@@ -0,0 +1,304 @@
+###########################################################
+# RapydScript Standard Library
+# http.client — HTTP/HTTPS connections via the Fetch API
+###########################################################
+#
+# Provides:
+#   HTTPConnection(host[, port[, timeout]])  — plain HTTP connection
+#   HTTPSConnection(host[, port[, timeout]]) — TLS/HTTPS connection
+#   HTTPResponse                             — response returned by getresponse()
+#   HTTPException                            — base exception
+#   NotConnected                             — no request has been sent yet
+#   InvalidURL                              — malformed URL or host
+#   RemoteDisconnected                       — server closed connection unexpectedly
+#   HTTP_PORT   = 80
+#   HTTPS_PORT  = 443
+#
+# Usage (inside an async function):
+#   from http.client import HTTPConnection, HTTPSConnection
+#
+#   async def fetch_page():
+#       conn = HTTPConnection('example.com')
+#       conn.request('GET', '/path', headers={'Accept': 'text/html'})
+#       resp = await conn.getresponse()
+#       print(resp.status, resp.reason)
+#       body = await resp.read()
+#       conn.close()
+#       return body
+#
+# For HTTPS use HTTPSConnection or pass a full https:// URL to HTTPConnection.
+#
+# Note: getresponse() wraps the browser/Node Fetch API and returns a Promise.
+# It must be awaited inside an async function.  There is no synchronous version
+# because JavaScript has no synchronous HTTP.
+#
+# Unlike Python's http.client, non-2xx responses do NOT raise an exception —
+# check resp.status yourself (matching the lower-level CPython behaviour).
+
+HTTP_PORT  = 80
+HTTPS_PORT = 443
+
+
+class HTTPException(Exception):
+    """Base class for http.client exceptions."""
+    pass
+
+
+class NotConnected(HTTPException):
+    """No request has been issued on this connection yet."""
+    pass
+
+
+class InvalidURL(HTTPException):
+    """The URL or host string is malformed."""
+    pass
+
+
+class RemoteDisconnected(HTTPException):
+    """The remote end closed the connection unexpectedly."""
+    pass
+
+
+class HTTPResponse:
+    """HTTP response object returned by HTTPConnection.getresponse().
+
+    Attributes
+    ----------
+    status  : int   — HTTP status code (e.g. 200)
+    reason  : str   — HTTP reason phrase (e.g. 'OK')
+    headers : dict  — lowercase header name → value mapping
+    url     : str   — final URL after any redirects
+    msg     : dict  — alias for headers (CPython compat)
+
+    Methods
+    -------
+    read([amt])         — Promise → full response body as str (amt ignored)
+    json()              — Promise → body parsed as JSON
+    getheader(name[, default]) — return header value or default
+    getheaders()        — list of [name, value] pairs
+    close()             — mark response as closed (no-op in JS)
+    """
+
+    def __init__(self, status, reason, headers, body_text, url):
+        self.status = status
+        self.reason = reason
+        self.url    = url
+        self._body  = body_text
+        self._closed = False
+        v"""
+        // Normalise headers to a plain null-prototype object so getheader()
+        // works with both plain dicts and ρσ_dict (web-repl / dict_literals).
+        var _hdrs = Object.create(null);
+        if (headers) {
+            if (headers.jsmap && typeof headers.jsmap.forEach === 'function') {
+                headers.jsmap.forEach(function(v, k) {
+                    _hdrs[String(k).toLowerCase()] = String(v);
+                });
+            } else if (typeof headers === 'object') {
+                Object.keys(headers).forEach(function(k) {
+                    if (k !== 'jsmap' && k !== '__class__') {
+                        _hdrs[k.toLowerCase()] = String(headers[k]);
+                    }
+                });
+            }
+        }
+        this.headers = _hdrs;
+        this.msg     = _hdrs;
+        """
+
+    def read(self, amt=None):
+        """Return the response body as a string (as a resolved Promise)."""
+        body = self._body
+        return v'Promise.resolve(body)'
+
+    def json(self):
+        """Parse the response body as JSON (as a resolved Promise)."""
+        body = self._body
+        return v'Promise.resolve(JSON.parse(body))'
+
+    def getheader(self, name, dflt=None):
+        """Return the value of header *name* (case-insensitive), or *dflt*."""
+        v"""
+        var key = name.toLowerCase();
+        return Object.prototype.hasOwnProperty.call(this.headers, key)
+            ? this.headers[key]
+            : dflt;
+        """
+
+    def getheaders(self):
+        """Return a list of [name, value] pairs for all response headers."""
+        result = []
+        v"""
+        var hdrs = this.headers;
+        Object.keys(hdrs).forEach(function(k) { result.push([k, hdrs[k]]); });
+        """
+        return result
+
+    def close(self):
+        self._closed = True
+
+    @property
+    def closed(self):
+        return self._closed
+
+
+class HTTPConnection:
+    """An HTTP connection to *host*.
+
+    Parameters
+    ----------
+    host    : str   — hostname (may include port as 'host:port')
+    port    : int   — port number; overrides any port in *host*
+    timeout : float — seconds before the request is aborted
+
+    Call request() to set up a request, then await getresponse() to execute it
+    and obtain an HTTPResponse.
+    """
+
+    _scheme = 'http'
+
+    def __init__(self, host, port=None, timeout=None, source_address=None):
+        self.host    = host
+        self.port    = port
+        self.timeout = timeout
+        self._method  = None
+        self._path    = None
+        self._body    = None
+        v"""this._headers = Object.create(null);"""
+
+    def _build_url(self, path):
+        """Construct the full URL from the stored scheme, host, port, and path."""
+        v"""
+        var scheme = this._scheme;
+        var host   = this.host;
+        var port   = this.port;
+        // If path is already absolute, return it directly
+        if (path.slice(0, 7) === 'http://' || path.slice(0, 8) === 'https://') {
+            return path;
+        }
+        // Append port unless it is the default for the scheme
+        if (port != null) {
+            var default_port = scheme === 'https' ? 443 : 80;
+            if (port !== default_port) {
+                host = host + ':' + port;
+            }
+        }
+        return scheme + '://' + host + path;
+        """
+
+    def set_debuglevel(self, level):
+        """Set debug level (no-op in JS)."""
+        pass
+
+    def connect(self):
+        """Establish the connection (no-op in JS; fetch handles this)."""
+        pass
+
+    def close(self):
+        """Discard any pending request state."""
+        self._method  = None
+        self._path    = None
+        self._body    = None
+        v"""this._headers = Object.create(null);"""
+
+    def putrequest(self, method, url, skip_host=False, skip_accept_encoding=False):
+        """Begin a request; use putheader() + endheaders() to add headers."""
+        self._method  = method
+        self._path    = url
+        self._body    = None
+        v"""this._headers = Object.create(null);"""
+
+    def putheader(self, header, argument):
+        """Add a single header to the pending request."""
+        v"""this._headers[header.toLowerCase()] = String(argument);"""
+
+    def endheaders(self, body=None):
+        """Finalise the request headers and optionally set the body."""
+        if body is not None:
+            self._body = body
+
+    def request(self, method, url, body=None, headers={}):
+        """Set up a request; call await getresponse() to execute it.
+
+        Parameters
+        ----------
+        method  : str  — HTTP verb ('GET', 'POST', etc.)
+        url     : str  — path (e.g. '/api/items') or full URL
+        body    : str  — request body; also switches method hint to POST
+        headers : dict — extra request headers
+        """
+        self._method  = method
+        self._path    = url
+        self._body    = body
+        v"""
+        this._headers = Object.create(null);
+        var h = headers;
+        if (h) {
+            // ρσ_dict (web-repl / dict_literals mode) stores keys in h.jsmap (a Map)
+            if (h.jsmap && typeof h.jsmap.forEach === 'function') {
+                h.jsmap.forEach(function(v, k) {
+                    this._headers[String(k).toLowerCase()] = String(v);
+                }.bind(this));
+            } else if (typeof h === 'object') {
+                Object.keys(h).forEach(function(k) {
+                    if (k !== 'jsmap' && k !== '__class__') {
+                        this._headers[k.toLowerCase()] = String(h[k]);
+                    }
+                }.bind(this));
+            }
+        }
+        """
+
+    def getresponse(self):
+        """Execute the pending request and return a Promise → HTTPResponse.
+
+        Raises HTTPException on network errors.
+        Non-2xx responses are returned normally (check resp.status yourself).
+        """
+        method  = self._method or 'GET'
+        path    = self._path or '/'
+        body    = self._body
+        headers = self._headers
+        timeout = self.timeout
+        v"""
+        var url   = this._build_url(path);
+        var _opts = { method: method, headers: headers };
+        if (body != null) { _opts.body = body; }
+        var _abort = null;
+        if (timeout != null && typeof AbortController !== 'undefined') {
+            var _ctrl = new AbortController();
+            _opts.signal = _ctrl.signal;
+            _abort = setTimeout(function() { _ctrl.abort(); }, timeout * 1000);
+        }
+        return Promise.resolve()
+            .then(function() { return fetch(url, _opts); })
+            .then(function(resp) {
+                if (_abort) { clearTimeout(_abort); _abort = null; }
+                var hdrs = {};
+                if (resp.headers && typeof resp.headers.forEach === 'function') {
+                    resp.headers.forEach(function(v, k) { hdrs[k] = v; });
+                }
+                return resp.text().then(function(body_text) {
+                    return new HTTPResponse(resp.status, resp.statusText, hdrs, body_text, resp.url);
+                });
+            })
+            .catch(function(e) {
+                if (_abort) { clearTimeout(_abort); _abort = null; }
+                if (e instanceof HTTPException) throw e;
+                throw new HTTPException(String(e));
+            });
+        """
+
+
+class HTTPSConnection(HTTPConnection):
+    """An HTTPS connection to *host* (TLS).
+
+    Identical to HTTPConnection but uses https:// as the default scheme.
+    Parameters are the same as HTTPConnection.
+    """
+
+    _scheme = 'https'
+
+    def __init__(self, host, port=None, timeout=None, source_address=None,
+                 context=None, check_hostname=None):
+        HTTPConnection.__init__(self, host, port, timeout, source_address)

package/src/lib/http/cookies.pyj

@@ -0,0 +1,236 @@
+###########################################################
+# RapydScript Standard Library
+# http.cookies — HTTP cookie parsing and generation
+###########################################################
+#
+# Provides:
+#   CookieError          — raised when a cookie value cannot be parsed
+#   Morsel               — represents a single cookie with its attributes
+#   SimpleCookie         — dict-like container of Morsel objects
+#
+# Usage:
+#   from http.cookies import SimpleCookie, CookieError
+#
+#   # Parse cookies from a Cookie request header
+#   c = SimpleCookie()
+#   c.load('session=abc123; user=alice')
+#   for name, morsel in c.items():
+#       print(name, morsel.value)
+#
+#   # Build a Set-Cookie response header
+#   c2 = SimpleCookie()
+#   c2['token'] = 'xyz'
+#   c2['token']['path']    = '/'
+#   c2['token']['max-age'] = 3600
+#   print(c2.output())   # Set-Cookie: token=xyz; Max-Age=3600; Path=/
+
+
+class CookieError(Exception):
+    """Raised when a cookie header cannot be parsed."""
+    pass
+
+
+# Attribute keys for Morsel (lowercase, matching the Set-Cookie directive names)
+_MORSEL_ATTRS = ['expires', 'path', 'comment', 'domain', 'max-age',
+                 'secure', 'httponly', 'version', 'samesite']
+
+
+class Morsel:
+    """A single cookie name/value pair plus its Set-Cookie attributes.
+
+    Attributes
+    ----------
+    key          : str  — cookie name
+    value        : str  — decoded cookie value
+    coded_value  : str  — value as it appears in the header (same as value here)
+
+    Cookie attributes (set via morsel['path'] = '/', etc.):
+    'expires', 'path', 'comment', 'domain', 'max-age',
+    'secure', 'httponly', 'version', 'samesite'
+    """
+
+    def __init__(self):
+        self.key         = None
+        self.value       = None
+        self.coded_value = None
+        self._attrs      = {}
+
+    def set(self, key, val, coded_val):
+        self.key         = key
+        self.value       = val
+        self.coded_value = coded_val
+
+    def __getitem__(self, k):
+        v"""
+        var lk = k.toLowerCase();
+        return Object.prototype.hasOwnProperty.call(this._attrs, lk)
+            ? this._attrs[lk]
+            : '';
+        """
+
+    def __setitem__(self, k, v):
+        v"""
+        var lk = k.toLowerCase();
+        this._attrs[lk] = v;
+        """
+
+    def isReservedKey(self, k):
+        v"""
+        var lk = k.toLowerCase();
+        for (var i = 0; i < _MORSEL_ATTRS.length; i++) {
+            if (_MORSEL_ATTRS[i] === lk) return true;
+        }
+        return false;
+        """
+
+    def OutputString(self):
+        """Return the cookie string (without the 'Set-Cookie:' prefix)."""
+        v"""
+        var parts = [this.key + '=' + this.coded_value];
+        var a     = this._attrs;
+        if (a['expires'])  { parts.push('expires='  + a['expires']); }
+        if (a['path'])     { parts.push('Path='     + a['path']); }
+        if (a['comment'])  { parts.push('Comment='  + a['comment']); }
+        if (a['domain'])   { parts.push('Domain='   + a['domain']); }
+        if (a['max-age'] !== undefined && a['max-age'] !== '') {
+            parts.push('Max-Age=' + a['max-age']);
+        }
+        if (a['version'])  { parts.push('Version='  + a['version']); }
+        if (a['samesite']) { parts.push('SameSite=' + a['samesite']); }
+        if (a['secure'])   { parts.push('Secure'); }
+        if (a['httponly']) { parts.push('HttpOnly'); }
+        return parts.join('; ');
+        """
+
+    def output(self, header='Set-Cookie'):
+        return header + ': ' + self.OutputString()
+
+    def __str__(self):
+        return self.OutputString()
+
+    def __repr__(self):
+        return '<Morsel: ' + str(self.key) + '=' + str(self.coded_value) + '>'
+
+
+def _parse_cookie_str(rawdata):
+    """Parse a Cookie or Set-Cookie header string into a dict of name→Morsel."""
+    result = {}
+    v"""
+    // Split on ';' to get individual name=value pairs.
+    // We only parse the name=value portion here (not Set-Cookie attributes);
+    // for SimpleCookie we treat each ';'-separated segment as a cookie if it
+    // contains '=', otherwise we skip it (it's a directive like 'HttpOnly').
+    var parts = String(rawdata).split(';');
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i].replace(/^\s+|\s+$/g, '');
+        if (part.length === 0) continue;
+        var eq = part.indexOf('=');
+        if (eq < 0) continue;
+        var name = part.slice(0, eq).replace(/^\s+|\s+$/g, '');
+        var val  = part.slice(eq + 1).replace(/^\s+|\s+$/g, '');
+        // Strip surrounding quotes if present
+        if (val.length >= 2 && val.charAt(0) === '"' && val.charAt(val.length - 1) === '"') {
+            val = val.slice(1, val.length - 1);
+        }
+        if (name.length === 0) continue;
+        var m = new Morsel();
+        m.set(name, val, val);
+        result[name] = m;
+    }
+    """
+    return result
+
+
+class SimpleCookie:
+    """A dict-like container of Morsel objects parsed from cookie headers.
+
+    cookie['name'] = 'value'    — set a cookie (creates/replaces a Morsel)
+    cookie['name']              — get the Morsel for 'name'
+    cookie['name']['path'] = '/'— set a cookie attribute
+
+    load(rawdata)               — parse cookie string into this container
+    output(header, sep)         — format all cookies as Set-Cookie lines
+    items()                     — [(name, morsel), ...]
+    keys()                      — [name, ...]
+    values()                    — [morsel, ...]
+    """
+
+    def __init__(self, input=None):
+        self._cookies = {}
+        if input is not None:
+            self.load(input)
+
+    def load(self, rawdata):
+        """Parse *rawdata* (a cookie header string) and merge into this cookie."""
+        parsed = _parse_cookie_str(rawdata)
+        v"""
+        Object.keys(parsed).forEach(function(k) {
+            this._cookies[k] = parsed[k];
+        }.bind(this));
+        """
+
+    def __getitem__(self, key):
+        v"""
+        if (!Object.prototype.hasOwnProperty.call(this._cookies, key)) {
+            throw new KeyError(key);
+        }
+        return this._cookies[key];
+        """
+
+    def __setitem__(self, key, val):
+        v"""
+        if (!Object.prototype.hasOwnProperty.call(this._cookies, key)) {
+            var m = new Morsel();
+            m.set(key, String(val), String(val));
+            this._cookies[key] = m;
+        } else {
+            this._cookies[key].value       = String(val);
+            this._cookies[key].coded_value = String(val);
+        }
+        """
+
+    def __contains__(self, key):
+        v"""return Object.prototype.hasOwnProperty.call(this._cookies, key);"""
+
+    def keys(self):
+        v"""return Object.keys(this._cookies);"""
+
+    def values(self):
+        v"""
+        var out = [];
+        Object.keys(this._cookies).forEach(function(k) { out.push(this._cookies[k]); }.bind(this));
+        return out;
+        """
+
+    def items(self):
+        v"""
+        var out = [];
+        Object.keys(this._cookies).forEach(function(k) {
+            out.push([k, this._cookies[k]]);
+        }.bind(this));
+        return out;
+        """
+
+    def output(self, header='Set-Cookie:', sep='\r\n'):
+        """Return all cookies formatted as Set-Cookie header lines."""
+        v"""
+        var lines = [];
+        var ck = this._cookies;
+        Object.keys(ck).forEach(function(k) {
+            lines.push(ck[k].output(header.replace(/:$/, '')));
+        });
+        return lines.join(sep);
+        """
+
+    def __str__(self):
+        return self.output()
+
+    def __repr__(self):
+        v"""
+        var parts = [];
+        var ck = this._cookies;
+        Object.keys(ck).forEach(function(k) {
+            parts.push(JSON.stringify(k) + ': ' + JSON.stringify(ck[k].coded_value));
+        });
+        return '<SimpleCookie: ' + parts.join(', ') + '>';
+        """