@enspirit/elo 0.9.7 → 0.9.8

package/dist/src/runtime.js

@@ -6,7 +6,7 @@
  * when needed, wrapped in an IIFE for encapsulation.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RUBY_HELPERS = exports.RUBY_HELPER_DEPS = exports.JS_HELPERS = exports.JS_HELPER_DEPS = void 0;
+exports.PY_HELPERS = exports.PY_HELPER_DEPS = exports.RUBY_HELPERS = exports.RUBY_HELPER_DEPS = exports.JS_HELPERS = exports.JS_HELPER_DEPS = void 0;
 /**
  * Individual JavaScript helper function snippets.
  * Each helper is a standalone function that can be included in the output.
@@ -370,4 +370,406 @@ end`,
   v.to_s
 end`,
 };
+/**
+ * Python helper function snippets.
+ * These are embedded in compiled Python output when needed.
+ * Special entries starting with _ are import statements, not functions.
+ */
+exports.PY_HELPER_DEPS = {
+    kEq: [],
+    kNeq: ['kEq'],
+    kFetch: [],
+    kFetchObject: ['kFetch'],
+    kFetchArray: ['kFetch'],
+    kDeepMerge: [],
+    kPatch: [],
+    kTypeOf: [],
+    kAssert: [],
+    kFail: [],
+    kAssertFails: [],
+    kAdd: [],
+    kSub: [],
+    kMul: [],
+    kDiv: [],
+    kMod: [],
+    kPow: [],
+    kNeg: [],
+    kBool: [],
+    kString: ['_elo_dur_to_iso'],
+    kParseDate: ['_elo_dt_helpers'],
+    kParseDatetime: ['_elo_dt_helpers'],
+    _elo_dt_helpers: ['_import_datetime', '_elo_duration'],
+    _elo_duration: ['_import_re'],
+    // Parser helpers
+    pAny: ['pOk'],
+    pNull: ['pOk', 'pFail'],
+    pString: ['pOk', 'pFail'],
+    pInt: ['pOk', 'pFail'],
+    pFloat: ['pOk', 'pFail'],
+    pBool: ['pOk', 'pFail'],
+    pDatetime: ['pOk', 'pFail', 'kParseDatetime'],
+    pSchema: ['pOk', 'pFail'],
+    pArray: ['pOk', 'pFail'],
+    pUnion: ['pFail'],
+    pSubtype: ['pOk', 'pFail'],
+};
+exports.PY_HELPERS = {
+    _import_math: `import math`,
+    _import_functools: `import functools`,
+    _import_datetime: `import datetime as _dt`,
+    _import_re: `import re`,
+    _elo_duration: `class EloDuration:
+    __slots__ = ('_ms',)
+    def __init__(self, ms):
+        self._ms = ms
+    @staticmethod
+    def from_iso(s):
+        m = re.match(r'^P(?:(\\d+)Y)?(?:(\\d+)M)?(?:(\\d+)W)?(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+(?:\\.\\d+)?)S)?)?$', s)
+        if not m: raise Exception('Invalid ISO duration: ' + s)
+        yrs = int(m.group(1) or 0)
+        mos = int(m.group(2) or 0)
+        wks = int(m.group(3) or 0)
+        dys = int(m.group(4) or 0)
+        hrs = int(m.group(5) or 0)
+        mns = int(m.group(6) or 0)
+        scs = float(m.group(7) or 0)
+        total_days = yrs * 365 + mos * 30 + wks * 7 + dys
+        return EloDuration(((total_days * 24 + hrs) * 60 + mns) * 60000 + scs * 1000)
+    def to_ms(self): return self._ms
+    def plus(self, other):
+        if isinstance(other, EloDuration): return EloDuration(self._ms + other._ms)
+        if isinstance(other, _dt.datetime): return _elo_dt_plus(other, self)
+        raise Exception('Cannot add duration to ' + type(other).__name__)
+    def minus(self, other):
+        if isinstance(other, EloDuration): return EloDuration(self._ms - other._ms)
+        raise Exception('Cannot subtract ' + type(other).__name__ + ' from duration')
+    def scale(self, n): return EloDuration(self._ms * n)
+    def divide(self, n): return EloDuration(self._ms / n)
+    def negate(self): return EloDuration(-self._ms)
+    def __eq__(self, other): return isinstance(other, EloDuration) and self._ms == other._ms
+    def __ne__(self, other): return not self.__eq__(other)
+    def __lt__(self, other): return self._ms < other._ms
+    def __le__(self, other): return self._ms <= other._ms
+    def __gt__(self, other): return self._ms > other._ms
+    def __ge__(self, other): return self._ms >= other._ms
+    def __repr__(self): return f'EloDuration({self._ms}ms)'
+    def in_seconds(self): return self._ms / 1000.0
+    def in_minutes(self): return self._ms / 60000.0
+    def in_hours(self): return self._ms / 3600000.0
+    def in_days(self): return self._ms / 86400000.0
+    def in_weeks(self): return self._ms / 604800000.0
+    def in_months(self): return self._ms / (30.4375 * 86400000.0)
+    def in_quarters(self): return self._ms / (91.3125 * 86400000.0)
+    def in_years(self): return self._ms / (365.25 * 86400000.0)`,
+    _elo_dt_helpers: `def _elo_dt_plus(dt, dur):
+    from datetime import timedelta
+    return dt + timedelta(milliseconds=dur.to_ms())
+def _elo_dt_minus_dur(dt, dur):
+    from datetime import timedelta
+    return dt - timedelta(milliseconds=dur.to_ms())
+def _elo_dt_diff(a, b):
+    diff = a - b
+    return EloDuration(diff.total_seconds() * 1000)
+def _elo_dt(y, mo, d, h=0, mi=0, s=0):
+    return _dt.datetime(y, mo, d, h, mi, s)
+def _elo_start_of_day(dt):
+    return dt.replace(hour=0, minute=0, second=0, microsecond=0)
+def _elo_end_of_day(dt):
+    return dt.replace(hour=23, minute=59, second=59, microsecond=999000)
+def _elo_start_of_week(dt):
+    d = dt - _dt.timedelta(days=dt.weekday())
+    return d.replace(hour=0, minute=0, second=0, microsecond=0)
+def _elo_end_of_week(dt):
+    d = dt + _dt.timedelta(days=6 - dt.weekday())
+    return d.replace(hour=23, minute=59, second=59, microsecond=999000)
+def _elo_start_of_month(dt):
+    return dt.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+def _elo_end_of_month(dt):
+    import calendar
+    last_day = calendar.monthrange(dt.year, dt.month)[1]
+    return dt.replace(day=last_day, hour=23, minute=59, second=59, microsecond=999000)
+def _elo_start_of_quarter(dt):
+    qm = ((dt.month - 1) // 3) * 3 + 1
+    return dt.replace(month=qm, day=1, hour=0, minute=0, second=0, microsecond=0)
+def _elo_end_of_quarter(dt):
+    import calendar
+    qm = ((dt.month - 1) // 3) * 3 + 3
+    last_day = calendar.monthrange(dt.year, qm)[1]
+    return dt.replace(month=qm, day=last_day, hour=23, minute=59, second=59, microsecond=999000)
+def _elo_start_of_year(dt):
+    return dt.replace(month=1, day=1, hour=0, minute=0, second=0, microsecond=0)
+def _elo_end_of_year(dt):
+    return dt.replace(month=12, day=31, hour=23, minute=59, second=59, microsecond=999000)`,
+    kAssert: `def kAssert(cond, msg="Assertion failed"):
+    if not cond: raise Exception(msg)
+    return True`,
+    kFail: `def kFail(msg):
+    raise Exception(msg)`,
+    kAssertFails: `def kAssertFails(fn):
+    try:
+        fn()
+        raise Exception("Expected function to fail but it did not")
+    except Exception as e:
+        if str(e) == "Expected function to fail but it did not": raise
+        return True`,
+    kEq: `def kEq(l, r):
+    if isinstance(l, EloDuration) and isinstance(r, EloDuration): return l == r
+    if isinstance(l, _dt.datetime) and isinstance(r, _dt.datetime): return l == r
+    if isinstance(l, list) and isinstance(r, list):
+        if len(l) != len(r): return False
+        return all(kEq(a, b) for a, b in zip(l, r))
+    if isinstance(l, dict) and isinstance(r, dict):
+        if set(l.keys()) != set(r.keys()): return False
+        return all(kEq(l[k], r[k]) for k in l)
+    return l == r`,
+    kNeq: `def kNeq(l, r):
+    return not kEq(l, r)`,
+    kTypeOf: `def kTypeOf(v):
+    if v is None: return 'Null'
+    if isinstance(v, EloDuration): return 'Duration'
+    if isinstance(v, _dt.datetime): return 'DateTime'
+    if isinstance(v, bool): return 'Bool'
+    if isinstance(v, int): return 'Int'
+    if isinstance(v, float): return 'Float'
+    if isinstance(v, str): return 'String'
+    if isinstance(v, list): return 'List'
+    if isinstance(v, dict): return 'Tuple'
+    if callable(v): return 'Function'
+    return 'Unknown'`,
+    kFetch: `def kFetch(data, path):
+    current = data
+    for segment in path:
+        if current is None: return None
+        if isinstance(segment, int):
+            if not isinstance(current, list): return None
+            if segment >= len(current): return None
+            current = current[segment]
+        else:
+            if not isinstance(current, dict): return None
+            current = current.get(segment)
+    return current`,
+    kFetchObject: `def kFetchObject(data, paths):
+    return {key: kFetch(data, paths[key]) for key in paths}`,
+    kFetchArray: `def kFetchArray(data, paths):
+    return [kFetch(data, p) for p in paths]`,
+    kPatch: `def kPatch(data, path, value):
+    if len(path) == 0: return value
+    seg = path[0]
+    rest = path[1:]
+    next_default = None if len(rest) == 0 else ([] if isinstance(rest[0], int) else {})
+    if isinstance(seg, int):
+        if data is not None and not isinstance(data, list): raise Exception('cannot patch array index on non-array')
+        arr = list(data) if isinstance(data, list) else []
+        while len(arr) <= seg: arr.append(None)
+        existing = arr[seg]
+        arr[seg] = kPatch(next_default if existing is None else existing, rest, value)
+        return arr
+    else:
+        if isinstance(data, list): raise Exception('cannot patch object key on array')
+        obj = dict(data) if isinstance(data, dict) else {}
+        existing = obj.get(seg)
+        obj[seg] = kPatch(next_default if existing is None else existing, rest, value)
+        return obj`,
+    kDeepMerge: `def kDeepMerge(a, b):
+    if not isinstance(a, dict) or not isinstance(b, dict): return b
+    result = dict(a)
+    for key in b:
+        result[key] = kDeepMerge(a.get(key), b[key])
+    return result`,
+    kFirst: `def kFirst(arr):
+    return arr[0] if len(arr) > 0 else None`,
+    kLast: `def kLast(arr):
+    return arr[-1] if len(arr) > 0 else None`,
+    kAt: `def kAt(arr, idx):
+    if idx < 0 or idx >= len(arr): return None
+    return arr[idx]`,
+    kIndexOf: `def kIndexOf(s, sub):
+    idx = s.find(sub)
+    return None if idx == -1 else idx`,
+    kSplit: `def kSplit(s, sep):
+    if s == '': return []
+    return s.split(sep)`,
+    kData: `def kData(v):
+    import json
+    if v is None: return None
+    if isinstance(v, str):
+        try: return json.loads(v)
+        except: raise Exception('invalid JSON: ' + repr(v))
+    return v`,
+    kString: `def kString(v):
+    if v is None: return 'null'
+    if isinstance(v, bool): return 'true' if v else 'false'
+    if isinstance(v, int): return str(v)
+    if isinstance(v, float): return str(v)
+    if isinstance(v, str): return "'" + v.replace("\\\\", "\\\\\\\\").replace("'", "\\\\'") + "'"
+    if isinstance(v, EloDuration): return _elo_dur_to_iso(v)
+    if isinstance(v, _dt.datetime):
+        if v.hour == 0 and v.minute == 0 and v.second == 0: return 'D' + v.strftime('%Y-%m-%d')
+        return 'D' + v.strftime('%Y-%m-%dT%H:%M:%S')
+    if isinstance(v, list): return '[' + ', '.join(kString(e) for e in v) + ']'
+    if isinstance(v, dict): return '{' + ', '.join(k + ': ' + kString(v[k]) for k in v) + '}'
+    return str(v)`,
+    _elo_dur_to_iso: `def _elo_dur_to_iso(d):
+    ms = d.to_ms()
+    if ms == 0: return 'PT0S'
+    neg = ms < 0
+    ms = abs(ms)
+    secs = ms / 1000
+    days = int(secs // 86400); secs -= days * 86400
+    hours = int(secs // 3600); secs -= hours * 3600
+    mins = int(secs // 60); secs -= mins * 60
+    s = '-P' if neg else 'P'
+    if days: s += str(days) + 'D'
+    if hours or mins or secs: s += 'T'
+    if hours: s += str(hours) + 'H'
+    if mins: s += str(mins) + 'M'
+    if secs: s += str(int(secs) if secs == int(secs) else secs) + 'S'
+    return s`,
+    kAdd: `def kAdd(l, r):
+    if isinstance(l, _dt.datetime) and isinstance(r, EloDuration): return _elo_dt_plus(l, r)
+    if isinstance(l, EloDuration) and isinstance(r, _dt.datetime): return _elo_dt_plus(r, l)
+    if isinstance(l, EloDuration) and isinstance(r, EloDuration): return l.plus(r)
+    return l + r`,
+    kSub: `def kSub(l, r):
+    if isinstance(l, _dt.datetime) and isinstance(r, EloDuration): return _elo_dt_minus_dur(l, r)
+    if isinstance(l, _dt.datetime) and isinstance(r, _dt.datetime): return _elo_dt_diff(l, r)
+    if isinstance(l, EloDuration) and isinstance(r, EloDuration): return l.minus(r)
+    return l - r`,
+    kMul: `def kMul(l, r):
+    if isinstance(l, EloDuration): return l.scale(r)
+    if isinstance(r, EloDuration): return r.scale(l)
+    return l * r`,
+    kDiv: `def kDiv(l, r):
+    if isinstance(l, EloDuration) and isinstance(r, (int, float)): return l.divide(r)
+    return l / r`,
+    kMod: `def kMod(l, r):
+    return l % r`,
+    kPow: `def kPow(l, r):
+    return l ** r`,
+    kNeg: `def kNeg(v):
+    if isinstance(v, EloDuration): return v.negate()
+    return -v`,
+    kBool: `def kBool(v):
+    if isinstance(v, bool): return v
+    if isinstance(v, str):
+        if v == 'true': return True
+        if v == 'false': return False
+        raise Exception('Cannot convert to Bool: ' + repr(v))
+    raise Exception('Cannot convert to Bool: ' + repr(v))`,
+    kParseDate: `def kParseDate(v):
+    if isinstance(v, _dt.datetime): return _elo_dt(v.year, v.month, v.day)
+    if isinstance(v, str):
+        parts = v.split('-')
+        if len(parts) == 3: return _elo_dt(int(parts[0]), int(parts[1]), int(parts[2]))
+    raise Exception('Cannot parse date: ' + repr(v))`,
+    kParseDatetime: `def kParseDatetime(v):
+    if isinstance(v, _dt.datetime): return v
+    if isinstance(v, str):
+        v2 = v.replace('Z', '')
+        if 'T' in v2:
+            dp, tp = v2.split('T')
+            dy, dm, dd = dp.split('-')
+            tps = tp.split(':')
+            return _elo_dt(int(dy), int(dm), int(dd), int(tps[0]), int(tps[1]), int(tps[2]) if len(tps) > 2 else 0)
+        parts = v2.split('-')
+        if len(parts) == 3: return _elo_dt(int(parts[0]), int(parts[1]), int(parts[2]))
+    raise Exception('Cannot parse datetime: ' + repr(v))`,
+    // Parser helpers - return Result: { "success": bool, "path": str, "message": str, "value": any, "cause": list }
+    pOk: `def pOk(v, p):
+    return {"success": True, "path": p, "message": "", "value": v, "cause": []}`,
+    pFail: `def pFail(p, m=None, c=None):
+    return {"success": False, "path": p, "message": m or "", "value": None, "cause": c or []}`,
+    pUnwrap: `def pUnwrap(r):
+    if r["success"]: return r["value"]
+    def find_error(e):
+        if e.get("message"): return e
+        if e.get("cause") and len(e["cause"]) > 0: return find_error(e["cause"][0])
+        return e
+    err = find_error(r)
+    raise Exception((err.get("path") or ".") + ": " + (err.get("message") or "type error"))`,
+    pAny: `def pAny(v, p):
+    return pOk(v, p)`,
+    pNull: `def pNull(v, p):
+    if v is None: return pOk(None, p)
+    return pFail(p, "expected Null, got " + type(v).__name__)`,
+    pString: `def pString(v, p):
+    if isinstance(v, str): return pOk(v, p)
+    return pFail(p, "expected String, got " + ("Null" if v is None else type(v).__name__))`,
+    pInt: `def pInt(v, p):
+    if isinstance(v, bool): return pFail(p, "expected Int, got Bool")
+    if isinstance(v, int): return pOk(v, p)
+    if isinstance(v, str):
+        try: return pOk(int(v), p)
+        except: pass
+    return pFail(p, "expected Int, got " + ("Null" if v is None else repr(v) if isinstance(v, str) else type(v).__name__))`,
+    pFloat: `def pFloat(v, p):
+    if isinstance(v, bool): return pFail(p, "expected Float, got Bool")
+    if isinstance(v, (int, float)): return pOk(float(v), p)
+    if isinstance(v, str):
+        try: return pOk(float(v), p)
+        except: pass
+    return pFail(p, "expected Float, got " + ("Null" if v is None else repr(v) if isinstance(v, str) else type(v).__name__))`,
+    pBool: `def pBool(v, p):
+    if isinstance(v, bool): return pOk(v, p)
+    if v == "true": return pOk(True, p)
+    if v == "false": return pOk(False, p)
+    return pFail(p, "expected Bool, got " + ("Null" if v is None else repr(v) if isinstance(v, str) else type(v).__name__))`,
+    pDatetime: `def pDatetime(v, p):
+    if isinstance(v, _dt.datetime): return pOk(v, p)
+    if isinstance(v, str):
+        try: return pOk(kParseDatetime(v), p)
+        except: pass
+    return pFail(p, "expected Datetime, got " + ("Null" if v is None else "invalid datetime " + repr(v) if isinstance(v, str) else type(v).__name__))`,
+    pSchema: `def pSchema(props, extras_mode, extras_parser=None):
+    known_keys = [p[0] for p in props]
+    def parser(v, p):
+        if not isinstance(v, dict): return pFail(p, "expected object, got " + ("Null" if v is None else type(v).__name__))
+        o = {}
+        for key, prop_parser, optional in props:
+            val = v.get(key)
+            if optional and val is None:
+                continue
+            r = prop_parser(val, p + "." + key)
+            if not r["success"]: return pFail(p, None, [r])
+            o[key] = r["value"]
+        if extras_mode == "closed":
+            for k in v:
+                if k not in known_keys: return pFail(p + "." + k, "unexpected attribute")
+        elif extras_mode == "typed" and extras_parser is not None:
+            for k in v:
+                if k not in known_keys:
+                    re = extras_parser(v[k], p + "." + k)
+                    if not re["success"]: return pFail(p, None, [re])
+                    o[k] = re["value"]
+        return pOk(o, p)
+    return parser`,
+    pArray: `def pArray(elem_parser):
+    def parser(v, p):
+        if not isinstance(v, list): return pFail(p, "expected array, got " + ("Null" if v is None else type(v).__name__))
+        a = []
+        for i, e in enumerate(v):
+            r = elem_parser(e, p + "." + str(i))
+            if not r["success"]: return pFail(p, None, [r])
+            a.append(r["value"])
+        return pOk(a, p)
+    return parser`,
+    pUnion: `def pUnion(parsers):
+    def parser(v, p):
+        causes = []
+        for up in parsers:
+            r = up(v, p)
+            if r["success"]: return r
+            causes.append(r)
+        return pFail(p, "no union alternative matched", causes)
+    return parser`,
+    pSubtype: `def pSubtype(base_parser, checks):
+    def parser(v, p):
+        r = base_parser(v, p)
+        if not r["success"]: return r
+        val = r["value"]
+        for label, check in checks:
+            if not check(val): return pFail(p, label)
+        return r
+    return parser`,
+};
 //# sourceMappingURL=runtime.js.map

package/dist/src/runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enspirit/elo",
-  "version": "0.9.7",
+  "version": "0.9.8",
   "description": "A small expression language that compiles to Ruby, Javascript and PostgreSQL",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",