ommlds 0.0.0.dev450__py3-none-any.whl → 0.0.0.dev451__py3-none-any.whl

ommlds/minichain/content/_marshal.py

@@ -9,6 +9,7 @@ from omlish import reflect as rfl
 from omlish.funcs import match as mfs
 
 from .images import ImageContent  # noqa
+from .json import JsonContent  # noqa
 from .materialize import CanContent
 from .materialize import _InnerCanContent
 from .sequence import BlockContent  # noqa
@@ -139,28 +140,48 @@ class _ImageContentUnmarshaler(msh.Unmarshaler):
 ##
 
 
+class _JsonContentMarshaler(msh.Marshaler):
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        return ta.cast(msh.Value, check.isinstance(o, JsonContent).v)
+
+
+class _JsonContentUnmarshaler(msh.Unmarshaler):
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        return JsonContent(v)
+
+
+##
+
+
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     extended_content_poly = msh.Polymorphism(
         ExtendedContent,
         [
             msh.Impl(InlineContent, 'inline'),
             msh.Impl(BlockContent, 'block'),
             msh.Impl(ImageContent, 'image'),
+            msh.Impl(JsonContent, 'json'),
             msh.Impl(TextContent, 'text'),
         ],
     )
 
     msh.install_standard_factories(
         msh.PolymorphismMarshalerFactory(extended_content_poly),
-        msh.TypeMapMarshalerFactory({ImageContent: _ImageContentMarshaler()}),
+        msh.TypeMapMarshalerFactory({
+            ImageContent: _ImageContentMarshaler(),
+            JsonContent: _JsonContentMarshaler(),
+        }),
         _ContentMarshalerFactory(),
         _CanContentMarshalerFactory(),
     )
 
     msh.install_standard_factories(
         msh.PolymorphismUnmarshalerFactory(extended_content_poly),
-        msh.TypeMapUnmarshalerFactory({ImageContent: _ImageContentUnmarshaler()}),
+        msh.TypeMapUnmarshalerFactory({
+            ImageContent: _ImageContentUnmarshaler(),
+            JsonContent: _JsonContentUnmarshaler(),
+        }),
         _ContentUnmarshalerFactory(),
         _CanContentUnmarshalerFactory(),
     )

ommlds/minichain/content/json.py

@@ -0,0 +1,13 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..json import JsonValue
+from .simple import SimpleSingleExtendedContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class JsonContent(SimpleSingleExtendedContent, lang.Final):
+    v: JsonValue

ommlds/minichain/content/materialize.py

@@ -130,7 +130,13 @@ class ContentMaterializer:
 
     @_materialize.register
     def _materialize_iterable(self, o: ta.Iterable) -> Content:
-        return [self.materialize(e) for e in o]
+        # `collections.abc.Iterable` appears as a virtual base in the dispatch c3.mro for ContentNamespace before `type`
+        # does (due to NamespaceMeta having `__iter__`), so handle that here too.
+        if isinstance(o, type) and issubclass(o, ContentNamespace):
+            return self._materialize_namespace_type(o)
+
+        else:
+            return [self.materialize(e) for e in o]
 
     @_materialize.register
     def _materialize_none(self, o: None) -> Content:
@@ -151,25 +157,12 @@ class ContentMaterializer:
     def _materialize_namespace_type(self, o: type[ContentNamespace]) -> Content:
         check.issubclass(o, ContentNamespace)
 
-        def rec(v: ta.Any) -> ta.Generator[Content]:
-            if isinstance(v, (bytes, bytearray, ta.Mapping)):
-                return
-
-            elif isinstance(v, type):
-                if issubclass(v, ContentNamespace):
-                    for n, e in v:
-                        if n.startswith('_'):
-                            continue
-                        yield from rec(e)
-
-            elif isinstance(v, ta.Iterable):
-                for e in v:
-                    yield from rec(e)
-
-            else:
-                yield self.materialize(v)
-
-        return list(rec(o))
+        out: list[Content] = []
+        for n, e in o:
+            if n.startswith('_'):
+                continue
+            out.append(self.materialize(e))
+        return out
 
     #
 

ommlds/minichain/content/prepare.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - re-softwrap
+"""
 import abc
 import dataclasses as dc
 import typing as ta

ommlds/minichain/json.py

@@ -1,3 +1,4 @@
+# ruff: noqa: UP007
 import typing as ta
 
 from omlish import dataclasses as dc
@@ -11,3 +12,22 @@ from omlish import lang
 class JsonSchema(lang.Final):
     name: str
     root: ta.Any
+
+
+##
+
+
+JsonValue: ta.TypeAlias = ta.Union[
+    ta.Mapping[str, 'JsonValue'],
+
+    ta.Sequence['JsonValue'],
+
+    str,
+
+    int,
+    float,
+
+    bool,
+
+    None,
+]

ommlds/minichain/lib/fs/context.py

@@ -8,6 +8,7 @@ from .binfiles import has_binary_file_extension
 from .binfiles import is_binary_file
 from .errors import RequestedPathDoesNotExistError
 from .errors import RequestedPathOutsideRootDirError
+from .errors import RequestedPathWriteNotPermittedError
 from .errors import RequestedPathWrongTypeError
 from .suggestions import get_path_suggestions
 
@@ -20,14 +21,23 @@ class FsContext:
             self,
             *,
             root_dir: str | None = None,
+            writes_permitted: bool = False,
     ) -> None:
         super().__init__()
 
         self._root_dir = root_dir
+        self._writes_permitted = writes_permitted
+
         self._abs_root_dir = os.path.abspath(root_dir) if root_dir is not None else None
 
     #
 
+    @property
+    def writes_permitted(self) -> bool:
+        return self._writes_permitted
+
+    #
+
     def check_requested_path(self, req_path: str) -> None:
         abs_req_path = os.path.abspath(req_path)
 
@@ -76,6 +86,7 @@ class FsContext:
             req_path: str,
             *,
             text: bool = False,
+            write: bool = False,
     ) -> os.stat_result:
         self.check_requested_path(req_path)
 
@@ -105,8 +116,11 @@ class FsContext:
                 actual_type='binary file',
             )
 
+        if write and not self._writes_permitted:
+            raise RequestedPathWriteNotPermittedError(req_path)
+
         return st
 
 
-def fs_tool_context() -> FsContext:
+def tool_fs_context() -> FsContext:
     return tool_context()[FsContext]

ommlds/minichain/lib/fs/errors.py

@@ -93,3 +93,9 @@ class RequestedPathDoesNotExistError(RequestedPathError):
             f'Requested path {self.requested_path!r} does not exist.',
             *([f' Did you mean one of these valid paths: {self.suggested_paths!r}?'] if self.suggested_paths else []),
         ])
+
+
+class RequestedPathWriteNotPermittedError(RequestedPathError):
+    @property
+    def content(self) -> str:
+        return f'Writes are not permitted to requested path {self.requested_path!r}.'

ommlds/minichain/lib/fs/tools/edit.py

@@ -0,0 +1,104 @@
+"""
+TODO:
+ - must read file before editing
+ - must re-read file if file has been modified
+ - loosened replacer helpers
+ - accept diff format impl
+ - injectable confirmation, diff format
+"""
+from omlish import lang
+
+from ....tools.execution.catalog import ToolCatalogEntry
+from ....tools.execution.reflect import reflect_tool_catalog_entry
+from ..context import tool_fs_context
+from ..errors import RequestedPathError
+
+
+##
+
+
+class EditToolError(RequestedPathError, lang.Abstract):
+    pass
+
+
+class EmptyNewStringError(EditToolError):
+    @property
+    def content(self) -> str:
+        return f'The requested edit to {self.requested_path!r} was given an empty "old_string" parameter.'
+
+
+class OldStringNotPresentError(EditToolError):
+    @property
+    def content(self) -> str:
+        return f'The requested edit to {self.requested_path!r} did not contain the given "old_string" parameter.'
+
+
+class OldStringPresentMultipleTimesError(EditToolError):
+    @property
+    def content(self) -> str:
+        return f'The requested edit to {self.requested_path!r} contained the given "old_string" parameter multiple times.'  # noqa
+
+
+##
+
+
+def execute_edit_tool(
+        *,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
+) -> str:
+    """
+    Edits the given file by replacing the string given by the 'old_string' parameter with the string given by the
+    'new_string' parameter.
+
+    The file must exist, must be a valid text file, and must be given as an absolute path.
+
+    If the 'replace_all' parameter is false (the default) then 'new_string' must be present exactly once in the file,
+    otherwise the operation will fail. If 'replace_all' is true then all instances of 'old_string' will be replaced by
+    'new_string', but the operation will fail if there are no instances of 'old_string'
+    present in the file.
+
+    For the operation to succeed, both 'old_string' and 'new_string' must be EXACT, including all exact indentation and
+    other whitespace. This *includes* trailing newlines - this operates on the file as a single string, not a list of
+    lines.
+
+    Args:
+        file_path: The path of the file to edit. Must be an absolute path.
+        old_string: The old string to be replaced. May not be empty, and must be exact, including all exact whitespace.
+        new_string: The new string to replace the old string with.
+        replace_all: If false (the default) then exactly one instance of 'old_string' must be present in the file to be
+            replaced. If true then all instances of 'old_string' will be replaced by 'new_string', but at least one
+            instance of 'old_string' must be present in the file.
+    """
+
+    if not old_string:
+        raise EmptyNewStringError(file_path)
+
+    ctx = tool_fs_context()
+    ctx.check_stat_file(file_path, text=True, write=True)
+
+    with open(file_path) as f:
+        old_file = f.read()
+
+    n = old_file.count(old_string)
+    if not n:
+        raise OldStringNotPresentError(file_path)
+
+    if not replace_all and n != 1:
+        raise OldStringPresentMultipleTimesError(file_path)
+
+    new_file = old_file.replace(old_string, new_string)
+
+    # FIXME: confirm lol
+
+    with open(file_path, 'w') as f:
+        f.write(new_file)
+
+    return 'The file has been edited successfully.'
+
+
+@lang.cached_function
+def edit_tool() -> ToolCatalogEntry:
+    return reflect_tool_catalog_entry(execute_edit_tool)

ommlds/minichain/lib/fs/tools/ls.py

@@ -5,7 +5,7 @@ from omlish import lang
 
 from ....tools.execution.catalog import ToolCatalogEntry
 from ....tools.execution.reflect import reflect_tool_catalog_entry
-from ..context import fs_tool_context
+from ..context import tool_fs_context
 
 
 ##
@@ -21,7 +21,7 @@ def execute_ls_tool(
         dir_path: The dir to list the contents of. Must be an absolute path.
     """
 
-    ctx = fs_tool_context()
+    ctx = tool_fs_context()
     ctx.check_stat_dir(dir_path)
 
     out = io.StringIO()

ommlds/minichain/lib/fs/tools/read.py

@@ -14,7 +14,7 @@ from ....tools.execution.catalog import ToolCatalogEntry
 from ....tools.execution.reflect import reflect_tool_catalog_entry
 from ....tools.reflect import tool_spec_override
 from ....tools.types import ToolParam
-from ..context import fs_tool_context
+from ..context import tool_fs_context
 
 
 ##
@@ -64,7 +64,7 @@ def execute_read_tool(
         line_offset: int = 0,
         num_lines: int = DEFAULT_MAX_NUM_LINES,
 ) -> str:
-    ctx = fs_tool_context()
+    ctx = tool_fs_context()
     ctx.check_stat_file(file_path, text=True)
 
     out = io.StringIO()

ommlds/minichain/lib/fs/tools/recursivels/execution.py

@@ -2,7 +2,7 @@ from omlish import lang
 
 from .....tools.execution.catalog import ToolCatalogEntry
 from .....tools.execution.reflect import reflect_tool_catalog_entry
-from ...context import fs_tool_context
+from ...context import tool_fs_context
 from .rendering import LsLinesRenderer
 from .running import LsRunner
 
@@ -23,7 +23,7 @@ def execute_recursive_ls_tool(
         A formatted string of the recursive directory contents.
     """
 
-    ft_ctx = fs_tool_context()
+    ft_ctx = tool_fs_context()
     ft_ctx.check_requested_path(base_path)
 
     root = LsRunner().run(base_path)

ommlds/minichain/lib/todo/context.py

@@ -1,5 +1,7 @@
 import typing as ta
 
+from omlish import dataclasses as dc
+
 from ...tools.execution.context import tool_context
 from .types import TodoItem
 
@@ -7,6 +9,15 @@ from .types import TodoItem
 ##
 
 
+def _try_int(s: str | None) -> int | None:
+    if s is None:
+        return None
+    try:
+        return int(s)
+    except ValueError:
+        return None
+
+
 class TodoContext:
     def __init__(
             self,
@@ -15,13 +26,29 @@ class TodoContext:
         super().__init__()
 
         self._items = items
+        self._next_id: int = 1
 
     def get_items(self) -> ta.Sequence[TodoItem] | None:
         return self._items
 
-    def set_items(self, items: ta.Sequence[TodoItem] | None) -> None:
+    def set_items(self, items: ta.Sequence[TodoItem] | None) -> ta.Sequence[TodoItem] | None:
+        if items and any(item.id is None for item in items):
+            max_id = max([
+                *[ii for item in items if (ii := _try_int(item.id)) is not None],
+                self._next_id - 1,
+            ])
+            new_items: list[TodoItem] = []
+            for item in items:
+                if item.id is None:
+                    item = dc.replace(item, id=str(max_id + 1))
+                    max_id += 1
+                new_items.append(item)
+            items = new_items
+            self._next_id = max_id + 1
+
         self._items = list(items) if items is not None else None
+        return items
 
 
-def todo_tool_context() -> TodoContext:
+def tool_todo_context() -> TodoContext:
     return tool_context()[TodoContext]

ommlds/minichain/lib/todo/tools/read.py

@@ -1,10 +1,12 @@
+import typing as ta
+
 from omlish import lang
-from omlish.formats import json
 
 from ....tools.execution.catalog import ToolCatalogEntry
 from ....tools.execution.reflect import reflect_tool_catalog_entry
 from ....tools.reflect import tool_spec_override
-from ..context import todo_tool_context
+from ..context import tool_todo_context
+from ..types import TodoItem
 
 
 ##
@@ -28,12 +30,15 @@ from ..context import todo_tool_context
         - Use this information to track progress and plan next steps.
     """,
 )
-def execute_todo_read_tool() -> str:
-    ctx = todo_tool_context()
+def execute_todo_read_tool() -> ta.Sequence[TodoItem]:
+    ctx = tool_todo_context()
 
-    return json.dumps_compact(ctx.get_items() or [])
+    return ctx.get_items() or []
 
 
 @lang.cached_function
 def todo_read_tool() -> ToolCatalogEntry:
-    return reflect_tool_catalog_entry(execute_todo_read_tool)
+    return reflect_tool_catalog_entry(
+        execute_todo_read_tool,
+        marshal_output=True,
+    )