omlish 0.0.0.dev418__py3-none-any.whl → 0.0.0.dev419__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev418'
-__revision__ = '768aa72e47d914554932c2598e2f832465969997'
+__version__ = '0.0.0.dev419'
+__revision__ = 'ec06deda53ea93f16a7dc690230fe51edce49e7b'
 
 
 #

omlish/daemons/launching.py

@@ -94,7 +94,7 @@ class Launcher:
             if (pid_file := self._pid_file) is not None:
                 if not isinstance(spawner, InProcessSpawner):
                     pidfile = es.enter_context(open_inheritable_pidfile(pid_file))
-                    pidfile_manager = lang.NopContextManager(pidfile)
+                    pidfile_manager = lang.ValueContextManager(pidfile)
 
                 else:
                     check.state(not self._reparent_process)

omlish/formats/json/backends/orjson.py

@@ -48,6 +48,7 @@ class Options:
 
     ##
 
+    @lang.cached_function
     def __int__(self) -> int:
         return (
             (oj.OPT_APPEND_NEWLINE if self.append_newline else 0) |

omlish/formats/toml/parser.py

@@ -49,8 +49,8 @@ import types
 import typing as ta
 
 
-TomlParseFloat = ta.Callable[[str], ta.Any]
-TomlKey = ta.Tuple[str, ...]
+TomlParseFloat = ta.Callable[[str], ta.Any]  # ta.TypeAlias
+TomlKey = ta.Tuple[str, ...]  # ta.TypeAlias
 TomlPos = int  # ta.TypeAlias
 
 

omlish/lang/__init__.py

@@ -145,22 +145,42 @@ with _auto_proxy_init(
     )
 
     from .contextmanagers import (  # noqa
-        AsyncContextManager,
         ContextManaged,
-        ContextManager,
-        ContextWrapped,
-        DefaultLockable,
-        Lockable,
+        SelfContextManaged,
+        ValueContextManager,
         NOP_CONTEXT_MANAGER,
-        NopContextManager,
-        Timer,
+
+        AsyncContextManaged,
+        SelfAsyncContextManaged,
+        ValueAsyncContextManager,
+        NOP_ASYNC_CONTEXT_MANAGER,
+
+        AsyncContextManager,
+
+        ContextManager,
+
+        maybe_managing,
+        disposing,
         breakpoint_on_exception,
         context_var_setting,
+
+        as_async_context_manager,
+
+        ContextWrappable,
+        ContextWrapped,
         context_wrapped,
+
+        Lockable,
+        DefaultLockable,
         default_lock,
-        disposing,
+
+        AsyncLockable,
+        DefaultAsyncLockable,
+        default_async_lock,
+
+        Timer,
+
         double_check_setdefault,
-        maybe_managing,
     )
 
     from .datetimes import (  # noqa
@@ -297,7 +317,7 @@ with _auto_proxy_init(
         just,
     )
 
-    from .maysyncs import (  # noqa
+    from .maysync import (  # noqa
         make_maysync_fn,
         make_maysync_generator_fn,
         make_maysync,
@@ -439,7 +459,7 @@ with _auto_proxy_init(
         Maybe,
     )
 
-    from ..lite.maysyncs import (  # noqa
+    from ..lite.maysync import (  # noqa
         mark_maysync,
         is_maysync,
 

omlish/lang/contextmanagers.py

@@ -2,6 +2,7 @@
 TODO:
  - AsyncExitStacked
  - lol does double_check_setdefault need a CowDict in FT?
+ - AsyncLockable, DefaultAsyncLockable
 """
 import abc
 import contextlib
@@ -21,16 +22,45 @@ V = ta.TypeVar('V')
 ##
 
 
-class _NOT_SET:  # noqa
-    def __new__(cls, *args, **kwargs):  # noqa
-        raise TypeError
+class ContextManaged(abc.ABC):  # noqa
+    def __enter__(self):
+        return None
+
+    def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        return None
 
 
-class ContextManaged:
+class SelfContextManaged(ContextManaged):
     def __enter__(self) -> ta.Self:
         return self
 
-    def __exit__(
+
+class ValueContextManager(ContextManaged, ta.Generic[T]):
+    def __init__(self, value: T) -> None:
+        super().__init__()
+
+        self._value = value
+
+    def __enter__(self) -> T:
+        return self._value
+
+
+NOP_CONTEXT_MANAGER = ValueContextManager(None)
+
+
+#
+
+
+class AsyncContextManaged(abc.ABC):  # noqa
+    async def __aenter__(self):
+        return None
+
+    async def __aexit__(
             self,
             exc_type: type[BaseException] | None,
             exc_val: BaseException | None,
@@ -39,23 +69,22 @@ class ContextManaged:
         return None
 
 
-class NopContextManager(ContextManaged):
-    def __init__(self, /, value: ta.Any = _NOT_SET) -> None:
+class SelfAsyncContextManaged(AsyncContextManaged):
+    async def __aenter__(self) -> ta.Self:
+        return self
+
+
+class ValueAsyncContextManager(AsyncContextManaged, ta.Generic[T]):
+    def __init__(self, value: T) -> None:
         super().__init__()
 
         self._value = value
 
-    def __enter__(self):
-        if (value := self._value) is _NOT_SET:
-            return self
-        else:
-            return value
-
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        raise TypeError
+    async def __aenter__(self) -> T:
+        return self._value
 
 
-NOP_CONTEXT_MANAGER = NopContextManager()
+NOP_ASYNC_CONTEXT_MANAGER = ValueAsyncContextManager(None)
 
 
 ##
@@ -90,6 +119,9 @@ class ContextManager(abc.ABC, ta.Generic[T]):
         return self._contextmanager.__exit__(exc_type, exc_val, exc_tb)
 
 
+#
+
+
 class AsyncContextManager(abc.ABC, ta.Generic[T]):
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
@@ -160,6 +192,15 @@ def context_var_setting(var: contextvars.ContextVar[T], val: T) -> ta.Iterator[T
 ##
 
 
+@contextlib.asynccontextmanager
+async def as_async_context_manager(cm: ta.ContextManager[T]) -> ta.AsyncIterator[T]:
+    with cm as v:
+        yield v
+
+
+##
+
+
 ContextWrappable: ta.TypeAlias = ta.ContextManager | str | ta.Callable[..., ta.ContextManager]
 
 
@@ -257,6 +298,30 @@ def default_lock(value: DefaultLockable, default: DefaultLockable = None) -> Loc
         raise TypeError(value)
 
 
+#
+
+
+AsyncLockable = ta.Callable[[], ta.AsyncContextManager]
+DefaultAsyncLockable = AsyncLockable | ta.AsyncContextManager | None
+
+
+def default_async_lock(value: DefaultAsyncLockable, default: DefaultAsyncLockable = None) -> AsyncLockable:
+    if value is None:
+        value = default
+
+    if value is None:
+        return lambda: NOP_ASYNC_CONTEXT_MANAGER
+
+    elif callable(value):
+        return value
+
+    elif isinstance(value, ta.AsyncContextManager):
+        return lambda: value
+
+    else:
+        raise TypeError(value)
+
+
 ##
 
 

omlish/lang/imports/proxyinit.py

@@ -512,8 +512,8 @@ class AutoProxyInit:
             self,
             init_globals: ta.MutableMapping[str, ta.Any],
             *,
-            disable: bool,
-            eager: bool,
+            disable: bool = False,
+            eager: bool = False,
     ) -> None:
         super().__init__()
 

omlish/lang/{maysyncs.py → maysync.py}

@@ -1,8 +1,8 @@
 import typing as ta
 
-from ..lite.maysyncs import MaysyncFn
-from ..lite.maysyncs import MaysyncGeneratorFn
-from ..lite.maysyncs import make_maysync as _make_maysync
+from ..lite.maysync import MaysyncFn
+from ..lite.maysync import MaysyncGeneratorFn
+from ..lite.maysync import make_maysync as _make_maysync
 from .functions import as_async
 
 

omlish/lifecycles/__init__.py

@@ -1,11 +1,21 @@
 from .abstract import (  # noqa
     AbstractLifecycle,
+
+    AbstractAsyncLifecycle,
 )
 
 from .base import (  # noqa
+    AnyLifecycleCallback,
+    AnyLifecycle,
+    AnyCallbackLifecycle,
+
+    LifecycleCallback,
     CallbackLifecycle,
     Lifecycle,
-    LifecycleCallback,
+
+    AsyncLifecycleCallback,
+    CallbackAsyncLifecycle,
+    AsyncLifecycle,
 )
 
 from .contextmanagers import (  # noqa
@@ -14,6 +24,9 @@ from .contextmanagers import (  # noqa
 )
 
 from .controller import (  # noqa
+    AnyLifecycleListener,
+    AnyLifecycleController,
+
     LifecycleController,
     LifecycleListener,
 )

omlish/lifecycles/abstract.py

@@ -3,11 +3,14 @@ import typing as ta
 from .. import cached
 from .. import dataclasses as dc
 from .. import lang
+from .base import AsyncLifecycle
 from .base import Lifecycle
 
 
 AbstractLifecycleT = ta.TypeVar('AbstractLifecycleT', bound='AbstractLifecycle')
 
+AbstractAsyncLifecycleT = ta.TypeVar('AbstractAsyncLifecycleT', bound='AbstractAsyncLifecycle')
+
 
 ##
 
@@ -44,3 +47,40 @@ class AbstractLifecycle(lang.Abstract):
 
     def _lifecycle_destroy(self) -> None:
         pass
+
+
+##
+
+
+class AbstractAsyncLifecycle(lang.Abstract):
+    @dc.dataclass(frozen=True)
+    class _Lifecycle(AsyncLifecycle, lang.Final, ta.Generic[AbstractAsyncLifecycleT]):
+        obj: AbstractAsyncLifecycleT
+
+        async def lifecycle_construct(self) -> None:
+            await self.obj._lifecycle_construct()  # noqa
+
+        async def lifecycle_start(self) -> None:
+            await self.obj._lifecycle_start()  # noqa
+
+        async def lifecycle_stop(self) -> None:
+            await self.obj._lifecycle_stop()  # noqa
+
+        async def lifecycle_destroy(self) -> None:
+            await self.obj._lifecycle_destroy()  # noqa
+
+    @cached.property
+    def _lifecycle(self) -> _Lifecycle[ta.Self]:
+        return AbstractAsyncLifecycle._Lifecycle(self)
+
+    async def _lifecycle_construct(self) -> None:
+        pass
+
+    async def _lifecycle_start(self) -> None:
+        pass
+
+    async def _lifecycle_stop(self) -> None:
+        pass
+
+    async def _lifecycle_destroy(self) -> None:
+        pass

omlish/lifecycles/base.py

@@ -4,50 +4,100 @@ from .. import dataclasses as dc
 from .. import lang
 
 
+R = ta.TypeVar('R')
+
+AnyLifecycleT = ta.TypeVar('AnyLifecycleT', bound='AnyLifecycle')
+AnyLifecycleCallback: ta.TypeAlias = ta.Callable[[AnyLifecycleT], R]
+
 LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
-LifecycleCallback: ta.TypeAlias = ta.Callable[[LifecycleT], None]
+LifecycleCallback: ta.TypeAlias = ta.Callable[[LifecycleT], R]
+
+AsyncLifecycleT = ta.TypeVar('AsyncLifecycleT', bound='AsyncLifecycle')
+AsyncLifecycleCallback: ta.TypeAlias = ta.Callable[[AsyncLifecycleT], R]
 
 
 ##
 
 
-class Lifecycle:
-    def lifecycle_construct(self) -> None:
-        pass
+class AnyLifecycle(lang.Abstract, ta.Generic[R]):
+    def lifecycle_construct(self) -> R | None:
+        return None
 
-    def lifecycle_start(self) -> None:
-        pass
+    def lifecycle_start(self) -> R | None:
+        return None
 
-    def lifecycle_stop(self) -> None:
-        pass
+    def lifecycle_stop(self) -> R | None:
+        return None
 
-    def lifecycle_destroy(self) -> None:
-        pass
+    def lifecycle_destroy(self) -> R | None:
+        return None
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class CallbackLifecycle(Lifecycle, lang.Final, ta.Generic[LifecycleT]):
-    on_construct: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
-    on_start: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
-    on_stop: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
-    on_destroy: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
+class AnyCallbackLifecycle(
+    AnyLifecycle[R],
+    lang.Abstract,
+    ta.Generic[AnyLifecycleT, R],
+):
+    on_construct: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
+    on_start: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
+    on_stop: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
+    on_destroy: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
 
     @ta.override
-    def lifecycle_construct(self) -> None:
+    def lifecycle_construct(self) -> R | None:
         if self.on_construct is not None:
-            self.on_construct(self)
+            return self.on_construct(self)
+        else:
+            return None
 
     @ta.override
-    def lifecycle_start(self) -> None:
+    def lifecycle_start(self) -> R | None:
         if self.on_start is not None:
-            self.on_start(self)
+            return self.on_start(self)
+        else:
+            return None
 
     @ta.override
-    def lifecycle_stop(self) -> None:
+    def lifecycle_stop(self) -> R | None:
         if self.on_stop is not None:
-            self.on_stop(self)
+            return self.on_stop(self)
+        else:
+            return None
 
     @ta.override
-    def lifecycle_destroy(self) -> None:
+    def lifecycle_destroy(self) -> R | None:
         if self.on_destroy is not None:
-            self.on_destroy(self)
+            return self.on_destroy(self)
+        else:
+            return None
+
+
+##
+
+
+class Lifecycle(AnyLifecycle[None]):
+    pass
+
+
+class CallbackLifecycle(
+    AnyCallbackLifecycle[LifecycleT, None],
+    lang.Final,
+    ta.Generic[LifecycleT],
+):
+    pass
+
+
+##
+
+
+class AsyncLifecycle(AnyLifecycle[ta.Awaitable[None]]):
+    pass
+
+
+class CallbackAsyncLifecycle(
+    AnyCallbackLifecycle[LifecycleT, ta.Awaitable[None]],
+    lang.Final,
+    ta.Generic[LifecycleT],
+):
+    pass

omlish/lifecycles/controller.py

@@ -1,99 +1,95 @@
+import abc
 import typing as ta
 
 from .. import check
 from .. import defs
 from .. import lang
-from .base import Lifecycle
+from .base import AnyLifecycle  # noqa
+from .base import Lifecycle  # noqa
 from .states import LifecycleState
 from .states import LifecycleStates
 from .transitions import LifecycleTransition
 from .transitions import LifecycleTransitions
 
 
+R = ta.TypeVar('R')
+
+AnyLifecycleT = ta.TypeVar('AnyLifecycleT', bound='AnyLifecycle')
+
 LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
 
 
 ##
 
 
-class LifecycleListener(ta.Generic[LifecycleT]):
-    def on_starting(self, obj: LifecycleT) -> None:
-        pass
+class AnyLifecycleListener(ta.Generic[AnyLifecycleT, R]):
+    def on_starting(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
-    def on_started(self, obj: LifecycleT) -> None:
-        pass
+    def on_started(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
-    def on_stopping(self, obj: LifecycleT) -> None:
-        pass
+    def on_stopping(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
-    def on_stopped(self, obj: LifecycleT) -> None:
-        pass
+    def on_stopped(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
 
-class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
+class AnyLifecycleController(AnyLifecycle[R], lang.Abstract, ta.Generic[AnyLifecycleT, R]):
     def __init__(
             self,
-            lifecycle: LifecycleT,
-            *,
-            lock: lang.DefaultLockable = None,
+            lifecycle: AnyLifecycleT,
     ) -> None:
         super().__init__()
 
-        self._lifecycle: LifecycleT = check.isinstance(lifecycle, Lifecycle)  # type: ignore
-        self._lock = lang.default_lock(lock, False)
+        self._lifecycle: AnyLifecycleT = check.isinstance(lifecycle, AnyLifecycle)  # type: ignore
 
         self._state = LifecycleStates.NEW
-        self._listeners: list[LifecycleListener[LifecycleT]] = []
+        self._listeners: list[AnyLifecycleListener[AnyLifecycleT, R]] = []
 
     defs.repr('lifecycle', 'state')
 
     @property
-    def lifecycle(self) -> LifecycleT:
+    def lifecycle(self) -> AnyLifecycleT:
         return self._lifecycle
 
     @property
     def state(self) -> LifecycleState:
         return self._state
 
-    def add_listener(self, listener: LifecycleListener[LifecycleT]) -> 'LifecycleController':
-        self._listeners.append(check.isinstance(listener, LifecycleListener))
+    def add_listener(self, listener: AnyLifecycleListener[AnyLifecycleT, R]) -> ta.Self:
+        self._listeners.append(check.isinstance(listener, AnyLifecycleListener))
         return self
 
+    @abc.abstractmethod
     def _advance(
             self,
             transition: LifecycleTransition,
-            lifecycle_fn: ta.Callable[[], None],
-            pre_listener_fn: ta.Callable[[LifecycleListener[LifecycleT]], ta.Callable[[LifecycleT], None]] | None = None,  # noqa
-            post_listener_fn: ta.Callable[[LifecycleListener[LifecycleT]], ta.Callable[[LifecycleT], None]] | None = None,  # noqa
-    ) -> None:
-        with self._lock():
-            if pre_listener_fn is not None:
-                for listener in self._listeners:
-                    pre_listener_fn(listener)(self._lifecycle)
-            check.state(self._state in transition.old)
-            self._state = transition.new_intermediate
-            try:
-                lifecycle_fn()
-            except Exception:
-                self._state = transition.new_failed
-                raise
-            self._state = transition.new_succeeded
-            if post_listener_fn is not None:
-                for listener in self._listeners:
-                    post_listener_fn(listener)(self._lifecycle)
+            lifecycle_fn: ta.Callable[[], R | None],
+            pre_listener_fn: ta.Callable[
+                [AnyLifecycleListener[AnyLifecycleT, R]],
+                ta.Callable[[AnyLifecycleT], R | None],
+            ] | None = None,
+            post_listener_fn: ta.Callable[
+                [AnyLifecycleListener[AnyLifecycleT, R]],
+                ta.Callable[[AnyLifecycleT], R | None],
+            ] | None = None,
+    ) -> R | None:
+        raise NotImplementedError
 
     ##
 
     @ta.override
-    def lifecycle_construct(self) -> None:
-        self._advance(
+    def lifecycle_construct(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.CONSTRUCT,
             self._lifecycle.lifecycle_construct,
         )
 
     @ta.override
-    def lifecycle_start(self) -> None:
-        self._advance(
+    def lifecycle_start(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.START,
             self._lifecycle.lifecycle_start,
             lambda l: l.on_starting,
@@ -101,8 +97,8 @@ class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
         )
 
     @ta.override
-    def lifecycle_stop(self) -> None:
-        self._advance(
+    def lifecycle_stop(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.STOP,
             self._lifecycle.lifecycle_stop,
             lambda l: l.on_stopping,
@@ -110,8 +106,59 @@ class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
         )
 
     @ta.override
-    def lifecycle_destroy(self) -> None:
-        self._advance(
+    def lifecycle_destroy(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.DESTROY,
             self._lifecycle.lifecycle_destroy,
         )
+
+
+##
+
+
+LifecycleListener: ta.TypeAlias = AnyLifecycleListener[LifecycleT, None]
+
+
+class LifecycleController(
+    AnyLifecycleController[LifecycleT, None],
+    Lifecycle,
+    ta.Generic[LifecycleT],
+):
+    def __init__(
+            self,
+            lifecycle: LifecycleT,
+            *,
+            lock: lang.DefaultLockable = None,
+    ) -> None:
+        super().__init__(lifecycle)
+
+        self._lock = lang.default_lock(lock, False)
+
+    def _advance(
+            self,
+            transition: LifecycleTransition,
+            lifecycle_fn: ta.Callable[[], None],
+            pre_listener_fn: ta.Callable[
+                [LifecycleListener[LifecycleT]],
+                ta.Callable[[LifecycleT], None],
+            ] | None = None,
+            post_listener_fn: ta.Callable[
+                [LifecycleListener[LifecycleT]],
+                ta.Callable[[LifecycleT], None],
+            ] | None = None,
+    ) -> None:
+        with self._lock():
+            if pre_listener_fn is not None:
+                for listener in self._listeners:
+                    pre_listener_fn(listener)(self._lifecycle)
+            check.state(self._state in transition.old)
+            self._state = transition.new_intermediate
+            try:
+                lifecycle_fn()
+            except Exception:
+                self._state = transition.new_failed
+                raise
+            self._state = transition.new_succeeded
+            if post_listener_fn is not None:
+                for listener in self._listeners:
+                    post_listener_fn(listener)(self._lifecycle)

omlish/marshal/base/registries.py

@@ -53,6 +53,7 @@ class Registry(ta.Generic[RegistryItemT]):
         self._dct: dict[ta.Any, _KeyRegistryItems[RegistryItemT]] = {}
         self._id_dct: ta.MutableMapping[ta.Any, _KeyRegistryItems[RegistryItemT]] = col.IdentityKeyDict()
 
+        self._version = 0
         self._sealed = False
 
     #
@@ -84,6 +85,9 @@ class Registry(ta.Generic[RegistryItemT]):
             *items: RegistryItemT,
             identity: bool = False,
     ) -> ta.Self:
+        if not items:
+            return self
+
         with self._lock:
             if self._sealed:
                 raise RegistrySealedError(self)
@@ -93,6 +97,8 @@ class Registry(ta.Generic[RegistryItemT]):
                 sr = dct[key] = _KeyRegistryItems(key)
             sr.add(*items)
 
+            self._version += 1
+
         return self
 
     #

omlish/math/__init__.py

@@ -1,83 +1,89 @@
-from .bits import (  # noqa
-    get_bit,
-    get_bits,
-    set_bit,
-    set_bits,
-)
-
-from .c import (  # noqa
-    cdiv,
-    cmod,
-)
-
-from .fixed import (  # noqa
-    CheckedFixedWidthIntError,
-    OverflowFixedWidthIntError,
-    UnderflowFixedWidthIntError,
-
-    FixedWidthInt,
-
-    SignedInt,
-    UnsignedInt,
-
-    CheckedInt,
-    ClampedInt,
-
-    AnyInt8,
-    AnyInt16,
-    AnyInt32,
-    AnyInt64,
-    AnyInt128,
-
-    CheckedInt8,
-    CheckedInt16,
-    CheckedInt32,
-    CheckedInt64,
-    CheckedInt128,
-
-    CheckedUint8,
-    CheckedUint16,
-    CheckedUint32,
-    CheckedUint64,
-    CheckedUint128,
-
-    ClampedInt8,
-    ClampedInt16,
-    ClampedInt32,
-    ClampedInt64,
-    ClampedInt128,
-
-    ClampedUint8,
-    ClampedUint16,
-    ClampedUint32,
-    ClampedUint64,
-    ClampedUint128,
-
-    WrappedInt8,
-    WrappedInt16,
-    WrappedInt32,
-    WrappedInt64,
-    WrappedInt128,
-
-    WrappedUint8,
-    WrappedUint16,
-    WrappedUint32,
-    WrappedUint64,
-    WrappedUint128,
-)
-
-from .floats import (  # noqa
-    isclose,
-    float_to_bytes,
-    bytes_to_float,
-)
-
-from .stats import (  # noqa
-    get_quantile,
-
-    Stats,
-)
-
-from .histogram import (  # noqa
-    SamplingHistogram,
-)
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .bits import (  # noqa
+        get_bit,
+        get_bits,
+        set_bit,
+        set_bits,
+    )
+
+    from .c import (  # noqa
+        cdiv,
+        cmod,
+    )
+
+    from .fixed import (  # noqa
+        CheckedFixedWidthIntError,
+        OverflowFixedWidthIntError,
+        UnderflowFixedWidthIntError,
+
+        FixedWidthInt,
+
+        SignedInt,
+        UnsignedInt,
+
+        CheckedInt,
+        ClampedInt,
+
+        AnyInt8,
+        AnyInt16,
+        AnyInt32,
+        AnyInt64,
+        AnyInt128,
+
+        CheckedInt8,
+        CheckedInt16,
+        CheckedInt32,
+        CheckedInt64,
+        CheckedInt128,
+
+        CheckedUint8,
+        CheckedUint16,
+        CheckedUint32,
+        CheckedUint64,
+        CheckedUint128,
+
+        ClampedInt8,
+        ClampedInt16,
+        ClampedInt32,
+        ClampedInt64,
+        ClampedInt128,
+
+        ClampedUint8,
+        ClampedUint16,
+        ClampedUint32,
+        ClampedUint64,
+        ClampedUint128,
+
+        WrappedInt8,
+        WrappedInt16,
+        WrappedInt32,
+        WrappedInt64,
+        WrappedInt128,
+
+        WrappedUint8,
+        WrappedUint16,
+        WrappedUint32,
+        WrappedUint64,
+        WrappedUint128,
+    )
+
+    from .floats import (  # noqa
+        isclose,
+        float_to_bytes,
+        bytes_to_float,
+    )
+
+    from .stats import (  # noqa
+        get_quantile,
+
+        Stats,
+    )
+
+    from .histogram import (  # noqa
+        SamplingHistogram,
+    )

omlish/subprocesses/{maysyncs.py → maysync.py}

@@ -4,7 +4,7 @@ import abc
 import sys
 import typing as ta
 
-from ..lite.maysyncs import make_maysync
+from ..lite.maysync import make_maysync
 from .asyncs import AbstractAsyncSubprocesses
 from .run import SubprocessRun
 from .run import SubprocessRunOutput

{omlish-0.0.0.dev418.dist-info → omlish-0.0.0.dev419.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev418
+Version: 0.0.0.dev419
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -132,7 +132,7 @@ dependencies of any kind**.
     of the presence or absence of an object, as in [many](https://en.cppreference.com/w/cpp/utility/optional)
     [other](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)
     [languages](https://doc.rust-lang.org/std/option/).
-  - **[maysyncs](https://github.com/wrmsr/omlish/blob/master/omlish/lite/maysyncs.py)** - A lightweight means of sharing
+  - **[maysync](https://github.com/wrmsr/omlish/blob/master/omlish/lite/maysync.py)** - A lightweight means of sharing
     code between sync and async contexts, eliminating the need for maintaining sync and async versions of functions.
 
 - **[bootstrap](https://github.com/wrmsr/omlish/blob/master/omlish/bootstrap)** - A centralized, configurable,

{omlish-0.0.0.dev418.dist-info → omlish-0.0.0.dev419.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=E7iojn9stTJMHyoeJLNlAbIfcUFXWRFTEiaSQK7iYOo,3568
+omlish/__about__.py,sha256=wXkYG_Y6_dahHEzlSoF0MBVQcUkILpOeAz1OmAcP31I,3568
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -129,7 +129,7 @@ omlish/configs/processing/rewriting.py,sha256=2zmyf7HcdN6kfuO9UGA88yeA_0A3xToUZe
 omlish/configs/processing/strings.py,sha256=Iw85H_AE2TG8vdpbgwhye-aqz5Hkn4J9mM32FdXEiGo,832
 omlish/daemons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/daemons/daemon.py,sha256=pUwomapIrUwXLnov9jlA5EU1vp4qEYcIiUxKD3SQyVo,3479
-omlish/daemons/launching.py,sha256=sNOYW939IGI4ZlLQ0bKxzXj6EyeOiwV7Upqhd5XfoHc,3747
+omlish/daemons/launching.py,sha256=OGr32q-g5fVHrIXfrXacCcwtpTEAKgO9EQtEQKmdf0s,3749
 omlish/daemons/reparent.py,sha256=uEs7pjzQkL8zhM8xADJhedmXXA7eDsu28639F5HkmpU,590
 omlish/daemons/services.py,sha256=laoUeJU7eVHuWl1062FBjPSD7jchOjhpYDc5FT2B3dM,3462
 omlish/daemons/spawning.py,sha256=psR73zOYjMKTqNpx1bMib8uU9wAZz62tw5TaWHrTdyY,5337
@@ -280,7 +280,7 @@ omlish/formats/json/backends/__init__.py,sha256=K5nAP-fCgUvaSylHqgRvmJp6j6PTWdMj
 omlish/formats/json/backends/base.py,sha256=Sv3lfDEx8X8t1yVerOGyN-ra3LeJDTKzuSsW9EBBxIk,1119
 omlish/formats/json/backends/default.py,sha256=PXVM8kM0LWRA1-aEAJ0JMfu9BDuHpPFCDgBme6JNdAw,1317
 omlish/formats/json/backends/jiter.py,sha256=8qv_XWGpcupPtVm6Z_egHio_iY1Kk8eqkvXTF6fVZr4,1193
-omlish/formats/json/backends/orjson.py,sha256=dHrD75f0ZOHve80Xpq8A2_ec69kXcj4nEM-pIdiemtU,3805
+omlish/formats/json/backends/orjson.py,sha256=X2jhKgUYYwaVuAppPQmfyncbOs2PJ7drqH5BioP-AYI,3831
 omlish/formats/json/backends/std.py,sha256=Hhiug5CkC1TXLFrE9rnMR2on7xP-RliSvfYA9ill_U0,3159
 omlish/formats/json/backends/ujson.py,sha256=U3iOlAURfiCdXbiNlXfIjDdtJDbDaLZsSuZriTUvbxs,2307
 omlish/formats/json/stream/__init__.py,sha256=LOQvJGUEqvm1exve1hnWoO3mlMadShaO2Cy7XjCiWbA,829
@@ -304,7 +304,7 @@ omlish/formats/json5/_antlr/Json5Visitor.py,sha256=fIp5GhQ2Sd-bKEBBcBd31FOoCLiV1
 omlish/formats/json5/_antlr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/toml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/toml/codec.py,sha256=5HFGWEPd9IFxPlRMRheX8FEDlRIzLe1moHEOj2_PFKU,342
-omlish/formats/toml/parser.py,sha256=O2M0penQV3t8NAsq_conJjvTsXI8iivUFuBg2a5J3dU,30643
+omlish/formats/toml/parser.py,sha256=aaZlEEPk0IQhfux_kjCY2K5mYYYDPNQ-4wWgZXskoAM,30675
 omlish/formats/toml/writer.py,sha256=9NT8sRy3I9KubxFx56Qbislvrdtbd23rEuBT-GSdUYA,3232
 omlish/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/funcs/builders.py,sha256=Av41RkDFbsVGzQ7cWzevCG-UqZhLCBSDT8DhyWKq1rQ,4006
@@ -424,14 +424,14 @@ omlish/iterators/iterators.py,sha256=RxW35yQ5ed8vBQ22IqpDXFx-i5JiLQdp7-pkMZXhJJ8
 omlish/iterators/recipes.py,sha256=wOwOZg-zWG9Zc3wcAxJFSe2rtavVBYwZOfG09qYEx_4,472
 omlish/iterators/tools.py,sha256=M16LXrJhMdsz5ea2qH0vws30ZvhQuQSCVFSLpRf_gTg,2096
 omlish/iterators/unique.py,sha256=BSE-eanva8byFCJi09Nt2zzTsVr8LnTqY1PIInGYRs0,1396
-omlish/lang/__init__.py,sha256=dyVY_3Scl1EWXXN4Pb26y4C7FVnBATP1KKfng2qbhag,9415
+omlish/lang/__init__.py,sha256=uquYJI6DghD_i3axIHlaP66ei8xp4exV1AO5BtoGFzg,9725
 omlish/lang/asyncs.py,sha256=SmzkYghQID77vcgm1Evnd3r9_jd5DlfzJ8uQK7nkh0E,1517
 omlish/lang/attrs.py,sha256=zFiVuGVOq88x45464T_LxDa-ZEq_RD9zJLq2zeVEBDc,5105
 omlish/lang/casing.py,sha256=cFUlbDdXLhwnWwcYx4qnM5c4zGX7hIRUfcjiZbxUD28,4636
 omlish/lang/clsdct.py,sha256=HAGIvBSbCefzRjXriwYSBLO7QHKRv2UsE78jixOb-fA,1828
 omlish/lang/collections.py,sha256=XI76WcSi4SclWmEGirErg7EzQUfjtmiK2xSK7jJISzY,2528
 omlish/lang/comparison.py,sha256=MOwEG0Yny-jBPHO9kQto9FSRyeNpQW24UABsghkrHxY,1356
-omlish/lang/contextmanagers.py,sha256=S4Dg_XqyP_ObmnEyKIDMVSCgyXV79IrvptZWsYSqFlM,7686
+omlish/lang/contextmanagers.py,sha256=aL2KPRq7b6ULp9lQDbxVLe0fOjutrhnRPHbxeWXgeKA,9010
 omlish/lang/datetimes.py,sha256=01tg21QOx-PWDlm-CSFTalym3vpqF0EKzeinmtcVNoU,379
 omlish/lang/descriptors.py,sha256=sVJ1Pr4ihp26Tu9UCvDSyfSf-DhBnFGnbpYIFF32c7g,6877
 omlish/lang/enums.py,sha256=F9tflHfaAoV2MpyuhZzpfX9-H55M3zNa9hCszsngEo8,111
@@ -441,7 +441,7 @@ omlish/lang/generators.py,sha256=a4D5HU_mySs2T2z3xCmE_s3t4QJkj0YRrK4-hhpGd0A,519
 omlish/lang/iterables.py,sha256=y1SX2Co3VsOeX2wlfFF7K3rwLvF7Dtre7VY6EpfwAwA,3338
 omlish/lang/lazyglobals.py,sha256=G1hwpyIgM4PUkVJ_St3K-EdQkHQdWpFOcXao6I5LwyY,1435
 omlish/lang/maybes.py,sha256=ES1LK-9ebh2GNKZ7YfrS4OEoYHFhfiWkme4wU6Blzo4,77
-omlish/lang/maysyncs.py,sha256=S90OrGQ8OShmcg7dt0Tf1GLTGCKwOPO80PRzaZHKsxY,1630
+omlish/lang/maysync.py,sha256=Yt0iFeEm53-iQTq91oCqeDqe5i1I-H7yL5ORe9zhx9U,1627
 omlish/lang/objects.py,sha256=eOhFyFiwvxqpbLs5QTEkXU3rdSt_tQXDgHoWF5SA28E,6119
 omlish/lang/outcomes.py,sha256=0PqxoKaGbBXU9UYZ6AE2QSq94Z-gFDt6wYdp0KomNQw,8712
 omlish/lang/overrides.py,sha256=IBzK6ljfLX6TLgIyKTSjhqTLcuKRkQNVtEOnBLS4nuA,2095
@@ -466,14 +466,14 @@ omlish/lang/classes/virtual.py,sha256=z0MYQD9Q5MkX8DzF325wDB4J9XoYbsB09jZ1omC62T
 omlish/lang/imports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lang/imports/conditional.py,sha256=R-E47QD95mMonPImWlrde3rnJrFKCCkYz71c94W05sc,1006
 omlish/lang/imports/lazy.py,sha256=Fhtb5tSAttff6G2pZdF8bh__GZlqJWHaMKtA8KubuX4,1479
-omlish/lang/imports/proxyinit.py,sha256=j3RMoA1Mop8XOspLQLkAoGQg0OZFpU6-BpXHoP7qa-0,19613
+omlish/lang/imports/proxyinit.py,sha256=Mw3_Or0x8Gz0YrMBIdyfdALnqNi4HXgv6ZZQDPMWL_o,19629
 omlish/lang/imports/resolving.py,sha256=DeRarn35Fryg5JhVhy8wbiC9lvr58AnllI9B_reswUE,2085
 omlish/lang/imports/traversal.py,sha256=pbFQIa880NGjSfcLsno2vE_G41_CLwDHb-7gWg2J3BI,2855
-omlish/lifecycles/__init__.py,sha256=1FjYceXs-4fc-S-C9zFYmc2axHs4znnQHcJVHdY7a6E,578
-omlish/lifecycles/abstract.py,sha256=c9UY7oxzYZ_neh5DPE4yv5HfuDv7B4Mj_9Zo-B8KDSs,1114
-omlish/lifecycles/base.py,sha256=DeUxARnOufWfBvhZQbonl1RVJgbrSeK5QNM6dWEuOwA,1398
+omlish/lifecycles/__init__.py,sha256=zOuvV4pErPwxcKUSgshmME2Duw9GrjwckpNmW3FPKng,810
+omlish/lifecycles/abstract.py,sha256=1nMCFVislFq-boMD6TK9APIkRm_5OzcpSsDs2XnByVQ,2248
+omlish/lifecycles/base.py,sha256=sCmzj2F-JcFD2qDsjNOPhKSbDIJaT9CEKK19RqkP-sg,2462
 omlish/lifecycles/contextmanagers.py,sha256=JAGYm11JYHDaq-9Vs5gPPQZMLTQDeHQWvWhcCVX4Qag,2078
-omlish/lifecycles/controller.py,sha256=U_4mfp3n0zxH3RgFrcAi6yODuLIR5RF-uwB2tEBdXIY,3467
+omlish/lifecycles/controller.py,sha256=DkbwzwVLuP9ZvG67jmhfW-am4YbcsE2qLNC82lVTXWw,4756
 omlish/lifecycles/manager.py,sha256=92s1IH_gDP25PM5tFuPMP2hD_6s5fPi_VzZiDS5549g,5449
 omlish/lifecycles/states.py,sha256=6gTdY3hn7-1sJ60lA3GeMx5RVKvXtFBBXE4KEjoO1Hs,1297
 omlish/lifecycles/transitions.py,sha256=3IFdWGtAeoy3XRlIyW7yCKV4e4Iof9ytkqklGMRFYQs,1944
@@ -490,7 +490,7 @@ omlish/lite/json.py,sha256=m0Ce9eqUZG23-H7-oOp8n1sf4fzno5vtK4AK_4Vc-Mg,706
 omlish/lite/logs.py,sha256=CWFG0NKGhqNeEgryF5atN2gkPYbUdTINEw_s1phbINM,51
 omlish/lite/marshal.py,sha256=K_wnZwfC8cftGILyE3RlmzQEYuZOfzkMLKey41zuwtM,20296
 omlish/lite/maybes.py,sha256=0p_fzb6yiOjEpvMKaQ53Q6CH1VPW1or7v7Lt1JIKcgM,4359
-omlish/lite/maysyncs.py,sha256=9_u3sS2VacmfffBjbUYiu5eYG2XJ2lCIpYewwbmvPDc,14391
+omlish/lite/maysync.py,sha256=9_u3sS2VacmfffBjbUYiu5eYG2XJ2lCIpYewwbmvPDc,14391
 omlish/lite/pycharm.py,sha256=FRHGcCDo42UzZXqNwW_DkhI-6kb_CmJKPiQ8F6mYkLA,1174
 omlish/lite/reflect.py,sha256=gI-Qlws9V-jND7kvCQFaIhBFrndVpDsikTQ7C6U2z3w,2434
 omlish/lite/reprs.py,sha256=2Bc7ukhKvYNTKmxPIuv9glZIph13C37y_W4fg9pBnu8,2006
@@ -534,7 +534,7 @@ omlish/marshal/base/errors.py,sha256=jmN3vl_U_hB6L0wAvuO7ORG27vXF7KEUk-1TxxK2mYA
 omlish/marshal/base/funcs.py,sha256=OeSb8T3R0HZmEnAI4lOhI1HPRurTAezzV3TZWdGGK9s,1558
 omlish/marshal/base/options.py,sha256=OoDErPmI0kswnqAtr7QYndlPYhIqIDarx833tKFT2R4,23
 omlish/marshal/base/overrides.py,sha256=543hP4_y2JRThUOamCE0dPfgucbepVV8e_YF-_PJk6U,993
-omlish/marshal/base/registries.py,sha256=lEpnKnIo0AANOk_PQ6nlEOpPcVa554I3zF0EsT8WuXU,3311
+omlish/marshal/base/registries.py,sha256=CHxjr2VPEwh2NwmnCB17AMY3YE9mWT9kUtPNiyTzGM8,3416
 omlish/marshal/base/types.py,sha256=DBczbVhz9z9zM4uux43KUnCEJUIW_JqVNyXMxPd--Cs,2472
 omlish/marshal/base/values.py,sha256=QF6OateG5kjRPHYza08wscThhg20oryf-aVQrxjfkC0,212
 omlish/marshal/composite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -581,7 +581,7 @@ omlish/marshal/trivial/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 omlish/marshal/trivial/any.py,sha256=XaqSW0fyq2FVE4PQ4IG0UaXr59kRVGccgZDlsNHrd_Q,852
 omlish/marshal/trivial/forbidden.py,sha256=fkvyBViUjrpfB6JJu47k-yxAvLkJw7JSZqSP-Abr_04,1092
 omlish/marshal/trivial/nop.py,sha256=PDXT0B9RR-ghG6ExuK9BH2J-nHEnoTYGNdVaNAyRzSk,506
-omlish/math/__init__.py,sha256=0N2LtQYsAit7wXDKa-Dj6XPkVzEviP-tB2BNQoMhzLI,1185
+omlish/math/__init__.py,sha256=bcdEEM3l4YNPJvTY_gD-7ARa5HEBNFTfvkVDTTzaNOQ,1531
 omlish/math/bits.py,sha256=pcTuWxNXXfG-CtTITNNbW3YConAkCeU8PLNcglCc43E,533
 omlish/math/c.py,sha256=JUHHZfVUUE4sb-6_LxJksbcLOLi9za0LdPs4dky5Ba8,308
 omlish/math/fixed.py,sha256=pplyqqD6BxZWS9UEc8MHLsiMwx0-D1GLTeB8EL6yxHs,7419
@@ -779,7 +779,7 @@ omlish/subprocesses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 omlish/subprocesses/asyncs.py,sha256=G9wj275s3r0ueftHFl73Lt4kMRBc2hJOKcoJQCDlBms,2663
 omlish/subprocesses/base.py,sha256=r60N3ad4ooSvdgFmT94L_xZEy7FMbMX6JcG2VgpHo6w,6139
 omlish/subprocesses/editor.py,sha256=xBrd7gY0akhRfDIBK5YIBrYMHECtl_8r499iKViyfpQ,2634
-omlish/subprocesses/maysyncs.py,sha256=y4q-LnuSYRmiCrncGoa9SwejCSWnq0Cnzzu9qHcq5EE,1445
+omlish/subprocesses/maysync.py,sha256=zMs54wliA5-Kd986shgo4YY3W_4pOCJKpIrun0VYPyM,1444
 omlish/subprocesses/run.py,sha256=8EeMm2FdNEFmEmbhhzJyHXASUhCCMMRN_-8ybqFhgLI,4378
 omlish/subprocesses/sync.py,sha256=L-ZNj9RrZd69XjlKrXjt-EJ-XUpQF8E35Mh3b3SI3vc,3671
 omlish/subprocesses/utils.py,sha256=v5uEzxmbmRvXwOl_0DtBa5Il6yITKYRgmVSGHcLsT4o,402
@@ -923,9 +923,9 @@ omlish/typedvalues/marshal.py,sha256=AtBz7Jq-BfW8vwM7HSxSpR85JAXmxK2T0xDblmm1HI0
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev418.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev418.dist-info/METADATA,sha256=URtPO-TW-SiCQpfOPv3fapEkG9oDcAdN3CIm5RCsbvA,19244
-omlish-0.0.0.dev418.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev418.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev418.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev418.dist-info/RECORD,,
+omlish-0.0.0.dev419.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev419.dist-info/METADATA,sha256=G3EL-J9uLveMopCZ00adkjfg8wh3IqMtmQm8iyZ0iGc,19242
+omlish-0.0.0.dev419.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev419.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev419.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev419.dist-info/RECORD,,