omlish 0.0.0.dev484__py3-none-any.whl → 0.0.0.dev506__py3-none-any.whl

omlish/_check.cc

@@ -0,0 +1,209 @@
+// @omlish-cext
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "structmember.h"
+
+#include <vector>
+
+//
+
+#define _MODULE_NAME "_check"
+#define _PACKAGE_NAME "omlish"
+#define _MODULE_FULL_NAME _PACKAGE_NAME "." _MODULE_NAME
+
+typedef struct check_state {
+    PyObject *typing_any;
+    PyTypeObject *nonetype;
+} check_state;
+
+static inline check_state * get_check_state(PyObject *module)
+{
+    void *state = PyModule_GetState(module);
+    assert(state != NULL);
+    return (check_state *)state;
+}
+
+//
+
+PyDoc_STRVAR(unpack_isinstance_spec_doc, "unpack_isinstance_spec(spec)");
+
+static PyObject * unpack_isinstance_spec(PyObject *module, PyObject *spec)
+{
+    check_state *state = get_check_state(module);
+
+    // If spec is a type, return (spec,)
+    if (PyType_Check(spec)) {
+        return PyTuple_Pack(1, spec);
+    }
+
+    PyObject *tuple_spec = nullptr;
+
+    // If not a tuple, wrap it in a tuple
+    if (!PyTuple_Check(spec)) {
+        tuple_spec = PyTuple_Pack(1, spec);
+        if (tuple_spec == nullptr) {
+            return nullptr;
+        }
+    } else {
+        // It's already a tuple, so we'll work with it
+        tuple_spec = spec;
+        Py_INCREF(tuple_spec);
+    }
+
+    // Check if None is in spec
+    Py_ssize_t size = PyTuple_Size(tuple_spec);
+    if (size < 0) {
+        Py_DECREF(tuple_spec);
+        return nullptr;
+    }
+
+    bool has_none = false;
+    bool has_any = false;
+
+    for (Py_ssize_t i = 0; i < size; i++) {
+        PyObject *item = PyTuple_GetItem(tuple_spec, i);  // borrowed reference
+        if (item == nullptr) {
+            Py_DECREF(tuple_spec);
+            return nullptr;
+        }
+
+        if (item == Py_None) {
+            has_none = true;
+        }
+
+        // Check if item is typing.Any
+        if (state->typing_any != nullptr) {
+            int cmp = PyObject_RichCompareBool(item, state->typing_any, Py_EQ);
+            if (cmp < 0) {
+                Py_DECREF(tuple_spec);
+                return nullptr;
+            }
+            if (cmp) {
+                has_any = true;
+            }
+        }
+    }
+
+    // If typing.Any is in spec, return (object,)
+    if (has_any) {
+        Py_DECREF(tuple_spec);
+        return PyTuple_Pack(1, &PyBaseObject_Type);
+    }
+
+    // If None is in spec, filter it out and add NoneType
+    if (has_none) {
+        std::vector<PyObject*> filtered;
+        filtered.reserve(size);
+
+        for (Py_ssize_t i = 0; i < size; i++) {
+            PyObject *item = PyTuple_GetItem(tuple_spec, i);  // borrowed reference
+            if (item != Py_None) {
+                filtered.push_back(item);
+            }
+        }
+
+        // Add NoneType
+        filtered.push_back((PyObject *)state->nonetype);
+
+        // Create new tuple
+        PyObject *result = PyTuple_New(filtered.size());
+        if (result == nullptr) {
+            Py_DECREF(tuple_spec);
+            return nullptr;
+        }
+
+        for (size_t i = 0; i < filtered.size(); i++) {
+            Py_INCREF(filtered[i]);
+            PyTuple_SET_ITEM(result, i, filtered[i]);
+        }
+
+        Py_DECREF(tuple_spec);
+        return result;
+    }
+
+    // Return the tuple as-is
+    return tuple_spec;
+}
+
+//
+
+PyDoc_STRVAR(check_doc, "Native C++ implementations for omlish.lite.check");
+
+static int check_exec(PyObject *module)
+{
+    check_state *state = get_check_state(module);
+
+    // Get typing.Any
+    PyObject *typing_module = PyImport_ImportModule("typing");
+    if (typing_module == nullptr) {
+        // If typing module is not available, just set to nullptr
+        PyErr_Clear();
+        state->typing_any = nullptr;
+    } else {
+        state->typing_any = PyObject_GetAttrString(typing_module, "Any");
+        Py_DECREF(typing_module);
+        if (state->typing_any == nullptr) {
+            PyErr_Clear();
+        }
+    }
+
+    // Get NoneType (type(None))
+    state->nonetype = Py_TYPE(Py_None);
+    Py_INCREF(state->nonetype);
+
+    return 0;
+}
+
+static int check_traverse(PyObject *module, visitproc visit, void *arg)
+{
+    check_state *state = get_check_state(module);
+    Py_VISIT(state->typing_any);
+    Py_VISIT(state->nonetype);
+    return 0;
+}
+
+static int check_clear(PyObject *module)
+{
+    check_state *state = get_check_state(module);
+    Py_CLEAR(state->typing_any);
+    Py_CLEAR(state->nonetype);
+    return 0;
+}
+
+static void check_free(void *module)
+{
+    check_clear((PyObject *)module);
+}
+
+static PyMethodDef check_methods[] = {
+    {"unpack_isinstance_spec", (PyCFunction)unpack_isinstance_spec, METH_O, unpack_isinstance_spec_doc},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef_Slot check_slots[] = {
+    {Py_mod_exec, (void *) check_exec},
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+    {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED},
+    {0, NULL}
+};
+
+static struct PyModuleDef check_module = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = _MODULE_NAME,
+    .m_doc = check_doc,
+    .m_size = sizeof(check_state),
+    .m_methods = check_methods,
+    .m_slots = check_slots,
+    .m_traverse = check_traverse,
+    .m_clear = check_clear,
+    .m_free = check_free,
+};
+
+extern "C" {
+
+PyMODINIT_FUNC PyInit__check(void)
+{
+    return PyModuleDef_Init(&check_module);
+}
+
+}

omlish/check.py

@@ -26,6 +26,17 @@ _callable = callable
 ##
 
 
+try:
+    from . import _check  # type: ignore
+except ImportError:
+    pass
+else:
+    setattr(Checks, '_unpack_isinstance_spec', _check.unpack_isinstance_spec)
+
+
+##
+
+
 def register_on_raise(fn: OnRaiseFn) -> None:
     check.register_on_raise(fn)
 

omlish/dataclasses/__init__.py

@@ -138,6 +138,10 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
 
     from .tools.replace import (  # noqa
         deep_replace,
+
+        replace_if,
+        replace_ne,
+        replace_is_not,
     )
 
     from .tools.repr import (  # noqa

omlish/dataclasses/impl/concerns/frozen.py

@@ -79,6 +79,9 @@ class FrozenGenerator(Generator[FrozenPlan]):
         if not ctx.cs.frozen:
             return None
 
+        if issubclass(ctx.cls, BaseException):
+            raise TypeError('cannot use frozen=True with subclass of BaseException')
+
         return PlanResult(FrozenPlan(
             fields=tuple(f.name for f in ctx.cs.fields),
             allow_dynamic_dunder_attrs=ctx.cs.allow_dynamic_dunder_attrs,
@@ -118,7 +121,7 @@ class FrozenGenerator(Generator[FrozenPlan]):
                 f'}}',
                 f'',
             ])
-            condition.append(f' or name in {set_ident}')
+            condition.append(f'or name in {set_ident}')
 
         return AddMethodOp(
             f'__{mth}__',

omlish/dataclasses/impl/generation/plans.py

@@ -1,9 +1,4 @@
-"""
-TODO:
- - sha1 is slow :/ key by repr but name by sha1
-"""
 import dataclasses as dc
-import re
 import typing as ta
 
 from .... import lang
@@ -21,15 +16,5 @@ class Plans:
         return iter(self.tup)
 
     @lang.cached_function(no_wrapper_update=True)
-    def render(self) -> str:
-        return _render(self)
-
-
-##
-
-
-_WS_PAT = re.compile(r'\s+')
-
-
-def _render(plans: Plans) -> str:
-    return _WS_PAT.sub('', repr(plans.tup))
+    def repr(self) -> str:
+        return repr(self)

omlish/dataclasses/impl/generation/processor.py

@@ -126,7 +126,7 @@ class GeneratorProcessor(Processor):
             ])
 
             if (vo := gp._ctx.option(Verbosity)) is not None and vo.debug:  # noqa
-                print(gp.prepare().plans.render(), file=sys.stderr)
+                print(gp.prepare().plans.repr(), file=sys.stderr)
                 print(file=sys.stderr)
                 print(comp_src, file=sys.stderr)
                 print(file=sys.stderr)
@@ -235,7 +235,7 @@ class GeneratorProcessor(Processor):
         #
 
         prep = self.prepare()
-        prep_plan_repr = repr(prep.plans)
+        prep_plan_repr = prep.plans.repr()
 
         #
 

omlish/dataclasses/impl/processing/driving.py

@@ -1,5 +1,6 @@
 import contextlib
 import contextvars
+import sys
 import typing as ta
 
 from .... import lang
@@ -36,6 +37,14 @@ def processing_options_context(*opts: ProcessingOption) -> ta.Iterator[None]:
 ##
 
 
+def _is_pkg_init_mod(mod_name: str) -> bool:
+    if (mod_obj := sys.modules.get(mod_name)) is None:
+        return False
+    if (mod_spec := getattr(mod_obj, '__spec__', None)) is None:
+        return False
+    return bool(mod_spec.submodule_search_locations)
+
+
 def drive_cls_processing(
         cls: type,
         cs: ClassSpec,
@@ -53,7 +62,10 @@ def drive_cls_processing(
     #
 
     cls_mod = cls.__module__
-    cls_pkg = cls_mod.rpartition('.')[0]
+    if _is_pkg_init_mod(cls_mod):
+        cls_pkg = cls_mod
+    else:
+        cls_pkg = cls_mod.rpartition('.')[0]
     pkg_cfg = lang.coalesce(PACKAGE_CONFIG_CACHE.get(cls_pkg), DEFAULT_NAMED_PACKAGE_CONFIG)
 
     #

omlish/dataclasses/tools/replace.py

@@ -1,4 +1,5 @@
 import dataclasses as dc
+import operator
 import typing as ta
 
 
@@ -15,3 +16,29 @@ def deep_replace(o: T, *args: str | ta.Callable[[ta.Any], ta.Mapping[str, ta.Any
         return dc.replace(o, **args[0](o))  # type: ignore
     else:
         return dc.replace(o, **{args[0]: deep_replace(getattr(o, args[0]), *args[1:])})  # type: ignore
+
+
+##
+
+
+def replace_if(
+        o: T,
+        fn: ta.Callable[[ta.Any, ta.Any], bool] = operator.eq,
+        /,
+        **kwargs: ta.Any,
+) -> T:
+    dct: dict[str, ta.Any] = {}
+    for k, v in kwargs.items():
+        if fn(getattr(o, k), v):
+            dct[k] = v  # noqa
+    if not dct:
+        return o
+    return dc.replace(o, **dct)  # type: ignore
+
+
+def replace_ne(o: T, **kwargs: ta.Any) -> T:
+    return replace_if(o, operator.ne, **kwargs)
+
+
+def replace_is_not(o: T, **kwargs: ta.Any) -> T:
+    return replace_if(o, operator.is_not, **kwargs)

omlish/diag/_pycharm/runhack.py

@@ -95,7 +95,7 @@ _BOOL_ENV_VAR_VALUES = {
 def _get_opt_env_bool(n, d):  # type: (str | None, bool) -> bool
     if n is None or n not in os.environ:
         return d
-    return _BOOL_ENV_VAR_VALUES[os.environ[n]]
+    return _BOOL_ENV_VAR_VALUES[os.environ[n].lower()]
 
 
 def _get_env_path_list(k):  # type: (str) -> list[str]

omlish/dispatch/functions.py

@@ -43,7 +43,7 @@ def function(func):  # noqa
         wrapper.dispatch = disp.dispatch  # type: ignore
 
     else:
-        from x.c._dispatch import function_wrapper  # noqa
+        from x.c._dispatch import function_wrapper  # type: ignore
         wrapper = function_wrapper(
             disp.dispatch,
             **{k: getattr(func, k) for k in functools.WRAPPER_ASSIGNMENTS if hasattr(func, k)},

omlish/formats/json/stream/lexing.py

@@ -338,7 +338,6 @@ class JsonStreamLexer(GenMachine[str, Token]):
             self._line = line
             self._col = col
 
-        last = None
         while True:
             c: str | None = None
 
@@ -358,7 +357,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
                         ofs += skip_to - char_in_str_pos
                         if (np := char_in_str.rfind('\n', char_in_str_pos, skip_to)) >= 0:
                             line += char_in_str.count('\n', char_in_str_pos, skip_to)
-                            col = np - char_in_str_pos
+                            col = skip_to - np - 1
                         else:
                             col += skip_to - char_in_str_pos
                         buf.write(char_in_str[char_in_str_pos:skip_to])
@@ -406,9 +405,18 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 self._raise(f'Unterminated string literal: {buf.getvalue()}')
 
             buf.write(c)
-            if c == q and last != '\\':
-                break
-            last = c
+            if c == q:
+                # Count consecutive backslashes before this quote
+                backslash_count = 0
+                buf_val = buf.getvalue()
+                check_pos = len(buf_val) - 2  # -2 because we just wrote the quote
+                while check_pos >= 0 and buf_val[check_pos] == '\\':
+                    backslash_count += 1
+                    check_pos -= 1
+
+                # Quote is escaped only if preceded by odd number of backslashes
+                if backslash_count % 2 == 0:
+                    break
 
         restore_state()
 

omlish/formats/json/stream/parsing.py

@@ -215,7 +215,7 @@ class JsonStreamParser(GenMachine[Token, Event]):
         except GeneratorExit:
             raise JsonStreamParseError('Expected object body') from None
 
-        if tok.kind == 'STRING' or (self._allow_trailing_commas and tok.kind == 'IDENT'):
+        if tok.kind == 'STRING' or (self._allow_extended_idents and tok.kind == 'IDENT'):
             k = tok.value
 
             try: