grida 0.0.1__py3-none-any.whl

grida/__init__.py

@@ -0,0 +1,22 @@
+"""Grida's minimal node-based workflow orchestration API."""
+
+from .workflow import (
+    CycleError,
+    DuplicateNodeError,
+    Node,
+    UnknownDependencyError,
+    Workflow,
+    WorkflowError,
+)
+
+__all__ = [
+    "CycleError",
+    "DuplicateNodeError",
+    "Node",
+    "UnknownDependencyError",
+    "Workflow",
+    "WorkflowError",
+]
+
+__version__ = "0.0.1"
+

grida/py.typed

@@ -0,0 +1 @@
+

grida/workflow.py

@@ -0,0 +1,145 @@
+"""Small, dependency-free primitives for executing node graphs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple
+
+
+NodeInputs = Mapping[str, Any]
+NodeOperation = Callable[[NodeInputs], Any]
+
+
+class WorkflowError(Exception):
+    """Base exception for invalid workflows."""
+
+
+class DuplicateNodeError(WorkflowError):
+    """Raised when two nodes have the same name."""
+
+
+class UnknownDependencyError(WorkflowError):
+    """Raised when a node depends on a node that is not in its workflow."""
+
+
+class CycleError(WorkflowError):
+    """Raised when workflow dependencies contain a cycle."""
+
+
+@dataclass(frozen=True)
+class Node:
+    """A named operation and the node outputs it requires."""
+
+    name: str
+    operation: NodeOperation
+    needs: Tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.name, str) or not self.name.strip():
+            raise ValueError("A node name must be a non-empty string.")
+        if not callable(self.operation):
+            raise TypeError("A node operation must be callable.")
+
+        normalized_needs = tuple(self.needs)
+        if any(not isinstance(name, str) or not name.strip() for name in normalized_needs):
+            raise ValueError("Dependency names must be non-empty strings.")
+        if len(set(normalized_needs)) != len(normalized_needs):
+            raise ValueError("A node cannot list the same dependency more than once.")
+        object.__setattr__(self, "needs", normalized_needs)
+
+
+class Workflow:
+    """A collection of nodes that can be validated and run locally."""
+
+    def __init__(self, name: str) -> None:
+        if not isinstance(name, str) or not name.strip():
+            raise ValueError("A workflow name must be a non-empty string.")
+        self.name = name
+        self._nodes: Dict[str, Node] = {}
+
+    @property
+    def nodes(self) -> Mapping[str, Node]:
+        """Return a read-only view of the workflow's nodes."""
+
+        return MappingProxyType(self._nodes)
+
+    def add(self, node: Node) -> "Workflow":
+        """Add a node and return this workflow for fluent declarations."""
+
+        if node.name in self._nodes:
+            raise DuplicateNodeError(f"Node {node.name!r} is already defined.")
+        self._nodes[node.name] = node
+        return self
+
+    def order(self) -> Tuple[str, ...]:
+        """Validate dependencies and return deterministic execution order."""
+
+        self._validate_dependencies()
+        ordered: List[str] = []
+        visiting: List[str] = []
+        visited = set()
+
+        def visit(name: str) -> None:
+            if name in visited:
+                return
+            if name in visiting:
+                cycle_start = visiting.index(name)
+                cycle = visiting[cycle_start:] + [name]
+                raise CycleError("Workflow contains a cycle: " + " -> ".join(cycle))
+
+            visiting.append(name)
+            for dependency in self._nodes[name].needs:
+                visit(dependency)
+            visiting.pop()
+            visited.add(name)
+            ordered.append(name)
+
+        for node_name in self._nodes:
+            visit(node_name)
+        return tuple(ordered)
+
+    def run(self, targets: Optional[Sequence[str]] = None) -> Dict[str, Any]:
+        """Execute all nodes, or only the dependency closure of target nodes."""
+
+        order = self.order()
+        selected = self._selected_nodes(targets)
+        outputs: Dict[str, Any] = {}
+
+        for name in order:
+            if name not in selected:
+                continue
+            node = self._nodes[name]
+            inputs = MappingProxyType(
+                {dependency: outputs[dependency] for dependency in node.needs}
+            )
+            outputs[name] = node.operation(inputs)
+        return outputs
+
+    def _validate_dependencies(self) -> None:
+        for node in self._nodes.values():
+            for dependency in node.needs:
+                if dependency not in self._nodes:
+                    raise UnknownDependencyError(
+                        f"Node {node.name!r} depends on unknown node {dependency!r}."
+                    )
+
+    def _selected_nodes(self, targets: Optional[Sequence[str]]) -> set:
+        if targets is None:
+            return set(self._nodes)
+
+        selected = set()
+
+        def select(name: str) -> None:
+            if name not in self._nodes:
+                raise UnknownDependencyError(f"Unknown target node {name!r}.")
+            if name in selected:
+                return
+            selected.add(name)
+            for dependency in self._nodes[name].needs:
+                select(dependency)
+
+        for target in targets:
+            select(target)
+        return selected
+

grida-0.0.1.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: grida
+Version: 0.0.1
+Summary: A node-based workflow orchestration SDK for digital content creation tools.
+License-Expression: MIT
+Keywords: dcc,pipeline,workflow,orchestration,node-graph
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Multimedia :: Graphics
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Grida
+
+Grida is an early-stage, node-based workflow orchestration SDK for digital
+content creation (DCC) pipelines.
+
+Version `0.0.1` provides a small, working graph kernel for declaring dependent
+operations, validating the graph, and executing nodes in deterministic
+topological order. It has no runtime dependencies.
+
+> **Early preview:** This release establishes the package name and the first
+> usable API. The API may change substantially before `1.0`.
+
+## Installation
+
+```bash
+python -m pip install grida
+```
+
+## Example
+
+```python
+from grida import Node, Workflow
+
+workflow = Workflow("character-export")
+workflow.add(Node("scene", lambda inputs: "hero.ma"))
+workflow.add(
+    Node(
+        "export",
+        lambda inputs: inputs["scene"].replace(".ma", ".fbx"),
+        needs=("scene",),
+    )
+)
+
+outputs = workflow.run()
+assert outputs["export"] == "hero.fbx"
+```
+
+A node receives a read-only mapping containing the outputs of its direct
+dependencies. In a real DCC integration, its operation can call the host API,
+launch a subprocess, or invoke an adapter captured by the operation.
+
+## Current scope
+
+Included in `0.0.1`:
+
+- Node and workflow declarations
+- Dependency validation
+- Cycle detection
+- Deterministic in-process execution
+- Typed exceptions for invalid graphs
+
+Not yet included:
+
+- Maya, Blender, Houdini, Unreal, or other host adapters
+- Persistent graphs or a graph file format
+- Distributed execution, caching, retries, or a scheduler
+- Stability guarantees for the public API
+
+## Development
+
+Run the tests with the Python standard library:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+## License
+
+MIT
+

grida-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+grida/__init__.py,sha256=1uy1l_Se-Xaog69XokkHDxUIdtOmIz-CnHxIKdGEWdw,361
+grida/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+grida/workflow.py,sha256=P9zYeKbBBkrm0NoADV8YVJmG45b3t3px9MHkJG_1jxc,4820
+grida-0.0.1.dist-info/licenses/LICENSE,sha256=sPPlBAJFhKmZdrOAgOEY0qycNv0RMAUole4mpxyUcfc,1076
+grida-0.0.1.dist-info/METADATA,sha256=kR5d_l8L_SKje3OSQYgeK7YeUu23FvqjN02Pf5u3bF8,2540
+grida-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+grida-0.0.1.dist-info/top_level.txt,sha256=Z9xz2YoszSIieuC4icN99_SyV6KqPsGtVUv0fAPkfJY,6
+grida-0.0.1.dist-info/RECORD,,

grida-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

grida-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Grida contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

grida-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+grida