@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/tui/session_tracker.py

@@ -1,123 +0,0 @@
-from dataclasses import dataclass
-from operator import attrgetter
-from typing import Iterable, Literal, Sequence
-
-from textual.signal import Signal
-
-type SessionState = Literal["notready", "busy", "asking", "idle"]
-
-
-@dataclass
-class SessionDetails:
-    """Tracks a concurrent session."""
-
-    index: int
-    """Index of session, used in sorting."""
-    mode_name: str
-    """The screen mode name."""
-    session_pk: int | None = None
-    """The DB session primary key, for deduplication when reloading."""
-    title: str = ""
-    """The title of the conversation."""
-    subtitle: str = ""
-    """The subtitle of the conversation."""
-    path: str = ""
-    """The project directory path."""
-    state: SessionState = "notready"
-    """The current state of the session."""
-    summary: str = ""
-    """Suplimentary information about the session."""
-
-    updates: int = 0
-    """Track updates to the session details."""
-
-
-class SessionTracker:
-    """Tracks concurrent agent settings"""
-
-    def __init__(self, signal: Signal[tuple[str, SessionDetails | None]]) -> None:
-        self.sessions: dict[str, SessionDetails] = {}
-        self._session_index = 0
-        self.signal = signal
-
-    @property
-    def session_count(self) -> int:
-        return len(self.sessions)
-
-    def new_session(self, session_pk: int | None = None) -> SessionDetails:
-        self._session_index += 1
-        mode_name = f"session-{self._session_index}"
-        session_meta = SessionDetails(
-            index=self._session_index,
-            mode_name=mode_name,
-            session_pk=session_pk,
-            title="New Session",
-        )
-        self.sessions[mode_name] = session_meta
-        return session_meta
-
-    def close_session(self, mode_name: str) -> None:
-        if mode_name in self.sessions:
-            del self.sessions[mode_name]
-            self.signal.publish((mode_name, None))
-
-    def get_session(self, mode_name: str) -> SessionDetails | None:
-        return self.sessions.get(mode_name, None)
-
-    def get_session_by_pk(self, session_pk: int) -> SessionDetails | None:
-        for session in self.sessions.values():
-            if session.session_pk == session_pk:
-                return session
-        return None
-
-    def update_session(
-        self,
-        mode_name: str,
-        title: str | None = None,
-        subtitle: str | None = None,
-        path: str | None = None,
-        state: SessionState | None = None,
-        session_pk: int | None = None,
-    ) -> SessionDetails:
-        session_details = self.sessions[mode_name]
-        if title is not None:
-            session_details.title = title
-        if subtitle is not None:
-            session_details.subtitle = subtitle
-        if path is not None:
-            session_details.path = path
-        if state is not None:
-            session_details.state = state
-        if session_pk is not None:
-            session_details.session_pk = session_pk
-        self.signal.publish((mode_name, session_details))
-        return session_details
-
-    @property
-    def ordered_sessions(self) -> Sequence[SessionDetails]:
-        return sorted(self.sessions.values(), key=attrgetter("index"))
-
-    def __iter__(self) -> Iterable[SessionDetails]:
-        return iter(self.ordered_sessions)
-
-    def session_cursor_move(
-        self, mode_name: str, direction: Literal[-1, +1], valid_modes: set[str] | None = None
-    ) -> str | None:
-        if valid_modes is None:
-            valid_modes = {s.mode_name for s in self.ordered_sessions}
-        else:
-            valid_modes = valid_modes & {s.mode_name for s in self.ordered_sessions}
-        if not valid_modes:
-            return None
-        ordered_valid = sorted(
-            [s for s in self.ordered_sessions if s.mode_name in valid_modes],
-            key=attrgetter("index")
-        )
-        mode_names = [s.mode_name for s in ordered_valid]
-        try:
-            mode_index = mode_names.index(mode_name)
-        except ValueError:
-            return None
-        mode_index = (mode_index + direction) % len(mode_names)
-        new_mode_name = mode_names[mode_index]
-        return new_mode_name

package/tui/settings.py

@@ -1,353 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-import copy
-from functools import cached_property
-from json import dumps
-from dataclasses import dataclass
-from typing import Callable, Iterable, KeysView, Sequence, TypedDict, Required
-
-from tui._loop import loop_last
-
-
-@dataclass
-class Setting:
-    """A setting or group of setting."""
-
-    key: str
-    title: str
-    type: str = "object"
-    help: str = ""
-    choices: list[str] | None = None
-    default: object | None = None
-    validate: list[dict] | None = None
-    children: dict[str, Setting] | None = None
-    editable: bool = True
-
-
-class SchemaDict(TypedDict, total=False):
-    """Typing for schema data structure."""
-
-    key: Required[str]
-    title: Required[str]
-    type: Required[str]
-    help: str
-    choices: list[str] | list[tuple[str, str]] | None
-    default: object
-    fields: list[SchemaDict]
-    validate: list[dict]
-    editable: bool
-
-
-type SettingsType = dict[str, object]
-
-
-INPUT_TYPES = {"boolean", "integer", "number", "string", "choices", "text"}
-
-
-class SettingsError(Exception):
-    """Base class for settings related errors."""
-
-
-class InvalidKey(SettingsError):
-    """The key is not in the schema."""
-
-
-class InvalidValue(SettingsError):
-    """The value was not of the expected type."""
-
-
-def parse_key(key: str) -> Sequence[str]:
-    return key.split(".")
-
-
-def get_setting[ExpectType](
-    settings: dict[str, object], key: str, expect_type: type[ExpectType] = object
-) -> ExpectType:
-    """Get a key from a settings structure.
-
-    Args:
-        settings: A settings dictionary.
-        key: A dot delimited key, e.g. "ui.column"
-        expect_type: The expected type of the value.
-
-    Raises:
-        InvalidValue: If the value is not the expected type.
-        KeyError: If the key doesn't exist in settings.
-
-    Returns:
-        The value matching they key.
-    """
-    for last, key_component in loop_last(parse_key(key)):
-        if last:
-            result = settings[key_component]
-            if not isinstance(result, expect_type):
-                raise InvalidValue(
-                    f"Expected {expect_type.__name__} type; found {result!r}"
-                )
-            return result
-        else:
-            sub_settings = settings.setdefault(key_component, {})
-            assert isinstance(sub_settings, dict)
-            settings = sub_settings
-    raise KeyError(key)
-
-
-class Schema:
-    def __init__(self, schema: list[SchemaDict]) -> None:
-        self.schema = schema
-
-    def set_value(self, settings: SettingsType, key: str, value: object) -> None:
-        schema = self.schema
-        keys = parse_key(key)
-        for last, key in loop_last(keys):
-            if last:
-                settings[key] = value
-            if key not in schema:
-                raise InvalidKey()
-            schema = schema[key]
-            assert isinstance(schema, dict)
-            if key not in settings:
-                settings = settings[key] = {}
-
-    def get_default(self, key: str) -> object | None:
-        """Get a default for the given key.
-
-        Args:
-            key: Key in dotted notation
-
-        Returns:
-            Default, or `None`.
-        """
-        defaults = self.defaults
-
-        schema_object = defaults
-        for last, sub_key in loop_last(parse_key(key)):
-            if last:
-                return schema_object.get(sub_key, None)
-            else:
-                if isinstance(schema_object, dict):
-                    schema_object = schema_object.get(sub_key, {})
-                else:
-                    return None
-        return None
-
-    @cached_property
-    def defaults(self) -> dict[str, object]:
-        settings: dict[str, object] = {}
-
-        def set_defaults(schema: list[SchemaDict], settings: dict[str, object]) -> None:
-            sub_settings: SettingsType
-            for sub_schema in schema:
-                key = sub_schema["key"]
-                assert isinstance(sub_schema, dict)
-                type = sub_schema["type"]
-
-                if type == "object":
-                    if fields := sub_schema.get("fields"):
-                        sub_settings = settings[key] = {}
-                        set_defaults(fields, sub_settings)
-
-                else:
-                    if (default := sub_schema.get("default")) is not None:
-                        settings[key] = default
-
-        set_defaults(self.schema, settings)
-        return settings
-
-    @cached_property
-    def key_to_type(self) -> Mapping[str, type]:
-        TYPE_MAP = {
-            "object": SchemaDict,
-            "string": str,
-            "integer": int,
-            "number": float,
-            "boolean": bool,
-            "choices": str,
-            "text": str,
-        }
-
-        def get_keys(setting: Setting) -> Iterable[tuple[str, type]]:
-            if setting.type == "object" and setting.children:
-                for child in setting.children.values():
-                    yield from get_keys(child)
-            else:
-                yield (setting.key, TYPE_MAP[setting.type])
-
-        keys = {
-            key: value_type
-            for setting in self.settings_map.values()
-            for key, value_type in get_keys(setting)
-        }
-        return keys
-
-    @property
-    def keys(self) -> KeysView:
-        return self.key_to_type.keys()
-
-    @cached_property
-    def settings_map(self) -> dict[str, Setting]:
-        form_settings: dict[str, Setting] = {}
-
-        def build_settings(
-            name: str, schema: SchemaDict, default: object = None
-        ) -> Setting:
-            schema_type = schema.get("type")
-            assert schema_type is not None
-            if schema_type == "object":
-                return Setting(
-                    name,
-                    schema["title"],
-                    schema_type,
-                    help=schema.get("help") or "",
-                    default=schema.get("default", default),
-                    validate=schema.get("validate"),
-                    children={
-                        schema["key"]: build_settings(f"{name}.{schema['key']}", schema)
-                        for schema in schema.get("fields", [])
-                    },
-                    editable=schema.get("editable", True),
-                )
-            else:
-                return Setting(
-                    name,
-                    schema["title"],
-                    schema_type,
-                    choices=schema.get("choices"),
-                    help=schema.get("help") or "",
-                    default=schema.get("default", default),
-                    validate=schema.get("validate"),
-                    editable=schema.get("editable", True),
-                )
-
-        for sub_schema in self.schema:
-            form_settings[sub_schema["key"]] = build_settings(
-                sub_schema["key"], sub_schema
-            )
-        return form_settings
-
-
-class Settings:
-    """Stores schema backed settings."""
-
-    def __init__(
-        self,
-        schema: Schema,
-        settings: dict[str, object],
-        on_set_callback: Callable[[str, object]] | None = None,
-    ) -> None:
-        self._schema = schema
-        self._settings = settings
-        self._on_set_callback = on_set_callback
-        self._changed: bool = False
-
-    @property
-    def changed(self) -> bool:
-        return self._changed
-
-    @property
-    def schema(self) -> Schema:
-        return self._schema
-
-    def up_to_date(self) -> None:
-        """Set settings as up to date (clears changed flag)."""
-        self._changed = False
-
-    @property
-    def json(self) -> str:
-        """Settings in JSON form."""
-        settings_json = dumps(self._settings, indent=4, separators=(", ", ": "))
-        return settings_json
-
-    def set_all(self) -> None:
-        if self._on_set_callback is not None:
-            for key in self._schema.keys:
-                self._on_set_callback(key, self.get(key))
-
-    def get[ExpectType](
-        self,
-        key: str,
-        expect_type: type[ExpectType] = object,
-        *,
-        expand: bool = True,
-    ) -> ExpectType:
-        from os.path import expandvars
-
-        sub_settings = self._settings
-
-        for last, sub_key in loop_last(parse_key(key)):
-            if last:
-                if (value := sub_settings.get(sub_key)) is None:
-                    default = self._schema.get_default(key)
-                    if default is None:
-                        default = expect_type()
-                    if not isinstance(default, expect_type):
-                        default = expect_type(default)
-                    assert isinstance(default, expect_type)
-                    return default
-
-                if isinstance(value, str) and expand:
-                    value = expandvars(value)
-                if not isinstance(value, expect_type):
-                    value = expect_type(value)
-                if not isinstance(value, expect_type):
-                    raise InvalidValue(
-                        f"key {sub_key!r} is not of expected type {expect_type.__name__}"
-                    )
-                return value
-            if not isinstance((sub_settings := sub_settings.get(sub_key, {})), dict):
-                default = self._schema.get_default(key)
-                if default is None:
-                    default = expect_type()
-                if not isinstance(default, expect_type):
-                    default = expect_type(default)
-                assert isinstance(default, expect_type)
-                return default
-        assert False, "Can't get here"
-
-    def set(self, key: str, value: object) -> None:
-        """Set a setting value.
-
-        Args:
-            key: Key in dot notation.
-            value: New value.
-        """
-        current_value = self.get(key, expand=False)
-        updated_settings = copy.deepcopy(self._settings)
-
-        setting = updated_settings
-        for last, sub_key in loop_last(parse_key(key)):
-            if last:
-                if current_value != value:
-                    self._changed = True
-                    self._settings = updated_settings
-                assert isinstance(setting, dict)
-                setting[sub_key] = value
-            else:
-                setting_node = setting.setdefault(sub_key, {})
-                if isinstance(setting_node, dict):
-                    setting = setting_node
-                else:
-                    assert isinstance(setting, dict)
-                    setting[sub_key] = {}
-                    setting = setting[sub_key]
-
-        if self._on_set_callback is not None:
-            self._on_set_callback(key, value)
-
-
-if __name__ == "__main__":
-    from rich import print
-    from rich.traceback import install
-
-    from tui.settings_schema import SCHEMA
-
-    install(show_locals=True, width=None)
-
-    schema = Schema(SCHEMA)
-    settings = schema.defaults
-    print(settings)
-
-    print(schema.settings_map)
-
-    print(schema.key_to_type)