writer 0.8.3rc4__py3-none-any.whl → 1.25.1rc1__py3-none-any.whl

writer/vault.py

@@ -0,0 +1,48 @@
+"""
+Writer Vault module for managing secret retrieval and caching.
+
+This module provides the WriterVault class which handles fetching and caching
+secrets from the Writer vault service, with support for environment-based
+configuration and error handling.
+"""
+
+import logging
+from typing import Dict, Optional
+
+import httpx
+
+from writer.keyvalue_storage import writer_kv_storage
+
+logger = logging.getLogger("vault")
+
+
+class WriterVault:
+    """Manages retrieval and caching of secrets from the Writer vault service."""
+
+    def __init__(self) -> None:
+        """Initialize vault with empty cache."""
+        self.secrets: Optional[Dict] = None
+
+    def get_secrets(self) -> Dict:
+        """Get cached secrets, fetching from vault if not already loaded."""
+        if self.secrets is None:
+            self.secrets = self._fetch()
+        return self.secrets
+
+    def refresh(self):
+        """Force refresh of secrets from the vault service."""
+        self.secrets = self._fetch()
+
+    def _fetch(self) -> Dict:
+        try:
+            data = writer_kv_storage.get("vault", "secret")
+            secrets = data.get("secret")
+            if isinstance(secrets, dict):
+                return secrets
+            logger.warning("Invalid vault response format: expected dict in 'secret' field")
+        except (httpx.HTTPStatusError, ValueError) as e:
+            logger.error("Failed to fetch vault secrets: %s", e)
+        return {}
+
+
+writer_vault = WriterVault()

writer/wf_project.py

@@ -7,6 +7,7 @@ This module manipulates the folder of a wf project stored into `wf`.
 """
 import dataclasses
 import glob
+import hashlib
 import io
 import json
 import logging
@@ -22,17 +23,18 @@ from typing import Any, Dict, List, Tuple
 from writer import core_ui
 from writer.ss_types import ComponentDefinition, MetadataDefinition, SourceFilesDirectory
 
-ROOTS = ['root', 'workflows_root']
-COMPONENT_ROOTS = ['page', 'workflows_workflow']
+ROOTS = ['root', 'blueprints_root']
+COMPONENT_ROOTS = ['page', 'blueprints_blueprint']
 
 shared_queue_write_files: typing.Optional[Queue] = None
 
 @dataclasses.dataclass
 class WfProjectContext:
     app_path: str
-    write_files_async_queue: Queue = Queue()
+    write_files_async_queue: Queue = dataclasses.field(default_factory=Queue)
     write_files_async_process: typing.Optional[multiprocessing.Process] = None
-    write_files_async_stop: Any = multiprocessing.Event() # Note: Event is a function, not a class in python, it can't be typed
+    write_files_async_stop: Any = dataclasses.field(default_factory=multiprocessing.Event)  # Note: Event is a function, not a class in python, it can't be typed
+    file_hashes: Dict[str, str] = dataclasses.field(default_factory=dict)
 
 
 def write_files_async(context: WfProjectContext, metadata: MetadataDefinition, components: Dict[str, ComponentDefinition]) -> None:
@@ -43,19 +45,26 @@ def write_files_async(context: WfProjectContext, metadata: MetadataDefinition, c
 
     >>> wf_project.write_files_async('app/hello', metadata={"writer_version": "0.1" }, components=...)
     """
+    
+    while not context.write_files_async_queue.empty():
+        try:
+            context.write_files_async_queue.get_nowait()
+        except queue.Empty:
+            break
+
     context.write_files_async_queue.put((context.app_path, metadata, components))
 
-def write_files(app_path: str, metadata: MetadataDefinition, components: Dict[str, ComponentDefinition]) -> None:
+def write_files(app_path: str, metadata: MetadataDefinition, components: Dict[str, ComponentDefinition], context: WfProjectContext) -> None:
     """
     Writes the meta data of the WF project to the `.wf` directory (metadata, components, ...).
 
     * the metadata.json file is written in json format
     * a file for the root component written in jsonline format
-    * a file for the workflows_root component written in jsonline format
+    * a file for the blueprints_root component written in jsonline format
     * one file per page is created in the form `components-page-{id}.json` in jsonline format
-    * one file per workflow is created in the form `components-workflows_workflow-{id}.json` in jsonline format
+    * one file per blueprint is created in the form `components-blueprints_blueprint-{id}.json` in jsonline format
 
-    >>> wf_project.write_files('app/hello', metadata={"writer_version": "0.1" }, components=...)
+    >>> wf_project.write_files('app/hello', metadata={"writer_version": "0.1" }, components=..., context=wf_project.WfProjectContext(app_path="app/path"))
     """
 
     wf_directory = os.path.join(app_path, ".wf")
@@ -64,10 +73,16 @@ def write_files(app_path: str, metadata: MetadataDefinition, components: Dict[st
 
     with io.open(os.path.join(wf_directory, "metadata.json"), "w") as f:
         json.dump(metadata, f, indent=4)
-
-    _write_root_files(wf_directory, components)
-    _write_component_files(wf_directory, components)
+        f.flush()
+        os.fsync(f.fileno())
+
+    logger = logging.getLogger("writer")
+    time_start = time.time()
+    logger.info("Saving project...")
+    _write_root_files(wf_directory, components, context)
+    _write_component_files(wf_directory, components, context)
     _remove_obsolete_component_files(wf_directory, components)
+    logger.info("Saved. Time elapsed: %.4fs", time.time() - time_start)
 
 
 def start_process_write_files_async(context: WfProjectContext, save_interval: float) -> None:
@@ -103,13 +118,13 @@ def read_files(app_path: str) -> Tuple[MetadataDefinition, dict[str, ComponentDe
     """
     Reads project files in the `.wf` folder.
 
-    The components are read in page and workflows_workflow order.
+    The components are read in page and blueprints_blueprint order.
 
     >>> metadata, components = wf_project.read_files('app/hello')
     """
     components: dict[str, ComponentDefinition] = {}
-    roots = ['root', 'workflows_root']
-    component_part_file_type = ['page', 'workflows_workflow']
+    roots = ['root', 'blueprints_root']
+    component_part_file_type = ['page', 'blueprints_blueprint']
 
     meta_data_path = os.path.join(app_path, ".wf", "metadata.json")
     try:
@@ -148,36 +163,13 @@ def read_files(app_path: str) -> Tuple[MetadataDefinition, dict[str, ComponentDe
     return metadata, components
 
 
-def migrate_obsolete_ui_json(app_path: str, metadata: MetadataDefinition) -> None:
-    """
-    Migrates a project that uses ui.json file to the current project format
-
-    The ui.json file is removed after the migration.
-
-    >>> wf_project.migrate_obsolete_ui_json('app/hello')
-    """
-    assert os.path.isfile(os.path.join(app_path, "ui.json")), f"ui.json file required for migration into {app_path}"
-
-    logger = logging.getLogger('writer')
-    with io.open(os.path.join(app_path, "ui.json"), "r") as f:
-        parsed_file = json.load(f)
-
-    if not isinstance(parsed_file, dict):
-        raise ValueError("No dictionary found in components file.")
-
-    file_payload = parsed_file
-    # metadata = file_payload.get("metadata", {})
-    components = file_payload.get("components", {})
-    write_files(app_path, metadata, components)
-    os.remove(os.path.join(app_path, "ui.json"))
-    logger.warning('project format has changed and has been migrated with success. ui.json file has been removed.')
-
-
-def create_default_workflows_root(abs_path: str) -> None:
-    with io.open(os.path.join(abs_path, '.wf', 'components-workflows_root.jsonl'), 'w') as f:
-        f.write('{"id": "workflows_root", "type": "workflows_root", "content": {}, "isCodeManaged": false, "position": 0, "handlers": {}, "visible": {"expression": true, "binding": "", "reversed": false}}')
+def create_default_blueprints_root(abs_path: str) -> None:
+    with io.open(os.path.join(abs_path, '.wf', 'components-blueprints_root.jsonl'), 'w') as f:
+        f.write('{"id": "blueprints_root", "type": "blueprints_root", "content": {}, "isCodeManaged": false, "position": 0, "handlers": {}, "visible": {"expression": true, "binding": "", "reversed": false}}')
         logger = logging.getLogger('writer')
-        logger.warning('project format has changed and has been migrated with success. components-workflows_root.jsonl has been added.')
+        logger.warning('project format has changed and has been migrated with success. components-blueprints_root.jsonl has been added.')
+        f.flush()
+        os.fsync(f.fileno())
 
 
 def _expected_component_fileinfos(components: dict[str, ComponentDefinition]) -> List[Tuple[str, str]]:
@@ -238,7 +230,7 @@ def _sort_wf_component_keys(obj: typing.Union[ComponentDefinition, dict]) -> Any
     return OrderedDict((k, _sort_wf_component_keys(v)) for k, v in sorted_items)
 
 
-def _write_component_files(wf_directory: str, components: Dict[str, ComponentDefinition]) -> None:
+def _write_component_files(wf_directory: str, components: Dict[str, ComponentDefinition], context: WfProjectContext) -> None:
     """
     Writes the component files in the .wf folder. It preserve obsolete files.
 
@@ -247,17 +239,48 @@ def _write_component_files(wf_directory: str, components: Dict[str, ComponentDef
     for component_id, filename in _expected_component_fileinfos(components):
         filtered_components = core_ui.filter_components_by(components, parent=component_id)
 
-        with io.open(os.path.join(wf_directory, filename), "w") as f:
-            for p in _order_components(filtered_components):
-                f.write(json.dumps(_sort_wf_component_keys(p)) + "\n")
+        file_path = os.path.join(wf_directory, filename)
+        file_contents = "".join(
+            [json.dumps(_sort_wf_component_keys(p)) + "\n" for p in _order_components(filtered_components)]
+        )
 
+        has_changed = _has_file_hash_changed(filename, file_contents, context)
+        if not has_changed:
+            continue
+
+        with io.open(file_path, "w") as f:
+            f.write(file_contents)
+            f.flush()
+            os.fsync(f.fileno())
 
-def _write_root_files(wf_directory, components):
+
+def _write_root_files(wf_directory, components, context: WfProjectContext):
     for root in ROOTS:
         root_component = components.get(root, None)
         if root_component:
+            file_contents = json.dumps(_sort_wf_component_keys(root_component))
+
+            has_changed = _has_file_hash_changed(f"components-{root}.jsonl", file_contents, context)
+            if not has_changed:
+                continue
+
             with io.open(os.path.join(wf_directory, f"components-{root}.jsonl"), "w") as f:
-                f.write(json.dumps(_sort_wf_component_keys(root_component)))
+                f.write(file_contents)
+                f.flush()
+                os.fsync(f.fileno())
+
+
+def _has_file_hash_changed(file_name: str, new_contents: str, context: WfProjectContext) -> bool:
+    """
+    Returns whether a hash of a file changed given new file contents;
+
+    Missing file counts as hash invalidation and return True.
+    """
+    new_hash = hashlib.md5(new_contents.encode('utf-8')).hexdigest()
+
+    old_hash = context.file_hashes.get(file_name)
+    context.file_hashes[file_name] = new_hash
+    return old_hash != new_hash
 
 
 def _order_components(components: Dict[str, ComponentDefinition]) -> List[ComponentDefinition]:
@@ -290,7 +313,7 @@ def _start_process_write_files_async_process(context: WfProjectContext, save_int
 
         if obj is not None:
             app_path, metadata, components = obj
-            write_files(app_path, metadata, components)
+            write_files(app_path, metadata, components, context)
 
         time.sleep(save_interval)
 
@@ -303,9 +326,8 @@ def is_project(path: str) -> bool:
     """
     has_main_py = os.path.isfile(os.path.join(path, "main.py"))
     has_wf_directory = os.path.isdir(os.path.join(path, ".wf"))
-    has_ui_json_file = os.path.isfile(os.path.join(path, "ui.json"))
 
-    return has_main_py and (has_wf_directory or has_ui_json_file)
+    return has_main_py and has_wf_directory
 
 
 def can_create_project(path: str) -> bool:
@@ -340,26 +362,25 @@ def build_source_files(app_path: str) -> SourceFilesDirectory:
         with open(path, "r", encoding='utf-8') as f:
             return f.read()
 
+
+    ignore_dirs = ['.venv', 'venv', '__pycache__', '.wf']
+    ignore_files = ['.DS_Store']
     files = []
     for root, dirs, filenames in os.walk(app_path):
-        # ignore specific folders
-        dirs[:] = [d for d in dirs if d not in {'.venv', 'venv', '__pycache__', '.wf'}]
+        dirs[:] = [d for d in dirs if d not in ignore_dirs]
         for filename in filenames:
-            files.append(os.path.realpath(os.path.join(root, filename)))
-
-    file_tree: SourceFilesDirectory = {
-        "type": "directory",
-        "children": {}
-    }
+            if filename not in ignore_files:
+                files.append(os.path.realpath(os.path.join(root, filename)))
 
+    file_tree: SourceFilesDirectory = { "type": "directory", "children": {} }
 
     for file in files:
         relative_path = os.path.relpath(file, app_path)
         parts = relative_path.split(os.sep)
         current_level: SourceFilesDirectory = file_tree
 
-        for part in parts:
-            if os.path.isdir(os.path.join(app_path, *parts[:parts.index(part) + 1])):
+        for i, part in enumerate(parts):
+            if os.path.isdir(os.path.join(app_path, *parts[: i + 1])):
                 if part not in current_level["children"]:
                     current_level["children"][part] = { "type": "directory", "children": {} }
 
@@ -372,13 +393,16 @@ def build_source_files(app_path: str) -> SourceFilesDirectory:
                     content = load_persisted_script(relative_path)
                     extension = os.path.splitext(relative_path)[1]
                     # limit only the first 100 characters to limit bandwidth usage, the rest will be lazy loaded
-                    exerpt = content if extension == '.py' else content[0:100]
+                    excerpt = content if extension == '.py' else content[0:100]
                     current_level["children"][part] = {
                         "type": "file",
-                        "content": exerpt,
-                        "complete": exerpt == content,
+                        "content": excerpt,
+                        "complete": excerpt == content,
                     }
-                except (UnicodeDecodeError, FileNotFoundError):
+                except UnicodeDecodeError:
+                    # TODO: get mimetype
+                    current_level["children"][part] = { "type": "binary" }
+                except  FileNotFoundError:
                     pass
 
     return file_tree

writer-1.25.1rc1.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: writer
+Version: 1.25.1rc1
+Summary: An open-source, Python framework for building feature-rich apps that are fully integrated with the Writer platform.
+License-File: LICENSE.txt
+Keywords: data apps,gui,ui,framework,writer framework
+Author: Writer, Inc.
+Requires-Python: >=3.9.2,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.9
+Provides-Extra: redis
+Requires-Dist: authlib (>=1.3.0,<1.7)
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: fastapi (>=0.89.1,<1)
+Requires-Dist: gitignore-parser (>=0.1.11,<0.2.0)
+Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: numpy (<=2.0.2) ; python_version < "3.10"
+Requires-Dist: numpy (>=2.0,<3.0) ; python_version >= "3.10"
+Requires-Dist: orjson (>=3.11.0,<4.0.0)
+Requires-Dist: pandas (>=2.2.0,<3)
+Requires-Dist: plotly (>=5.24.1,<6.0.0)
+Requires-Dist: pyarrow (>=15.0.0,<19.0.0)
+Requires-Dist: pydantic (>=2.6.0,<3)
+Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
+Requires-Dist: python-multipart (>=0.0.7,<1)
+Requires-Dist: pytz (>=2024.1,<2025.0)
+Requires-Dist: requests (>=2.31.0,<2.33)
+Requires-Dist: uvicorn (>=0.20.0,<1)
+Requires-Dist: watchdog (>=3.0.0,<4)
+Requires-Dist: websockets (>=12,<16)
+Requires-Dist: writer-sdk (>=2.3.1,<3)
+Project-URL: Documentation, https://dev.writer.com/framework
+Project-URL: Homepage, https://www.writer.com
+Project-URL: Repository, https://github.com/writer/writer-framework
+Description-Content-Type: text/markdown
+
+## What is Writer Framework?
+
+Writer Framework is an open-source framework for creating AI applications. Build user interfaces using a visual editor; write the backend code in Python.
+
+Writer Framework is fast and flexible with a clean, easily-testable syntax. It provides separation of concerns between UI and business logic, enabling more complex applications.
+
+## Quick Start
+
+### Installation
+
+Writer Framework works on Linux, Mac, and Windows. It supports Python versions 3.9.2 through 3.12.
+
+```sh
+pip install writer
+```
+
+### Create and Run Your First App
+
+```sh
+# Create a demo app
+writer hello
+
+# Create a new app
+writer create my_app
+
+# Edit your app (opens visual editor)
+writer edit my_app
+
+# Run your app
+writer run my_app
+```
+
+The `writer edit` command opens the visual editor in your browser where you can build your UI by dragging and dropping components.
+
+## Documentation
+
+For comprehensive guides, tutorials, and API reference, visit the [official documentation](https://dev.writer.com/framework/quickstart).
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## About Writer
+
+Writer is the full-stack generative AI platform for enterprises. Quickly and easily build and deploy generative AI apps with a suite of developer tools fully integrated with our platform of LLMs, graph-based RAG tools, AI guardrails, and more. Learn more at [writer.com](https://www.writer.com?utm_source=github&utm_medium=readme&utm_campaign=framework).
+
+## License
+
+This project is licensed under the Apache 2.0 License.
+