swarmauri 0.1.122.dev5__tar.gz → 0.1.124.dev4__tar.gz

{swarmauri-0.1.122.dev5 → swarmauri-0.1.124.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarmauri
-Version: 0.1.122.dev5
+Version: 0.1.124.dev4
 Summary: This repository includes core interfaces, standard ABCs and concrete references, third party plugins, and experimental modules for the swarmaURI framework.
 Home-page: http://github.com/swarmauri/swarmauri-sdk
 Author: Jacob Stewart

{swarmauri-0.1.122.dev5 → swarmauri-0.1.124.dev4}/swarmauri/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.122.dev5"
+__version__ = "0.1.124.dev4"
 __long_desc__ = """
 # swarmaURI sdk
 

swarmauri-0.1.124.dev4/swarmauri/core/chains/IChainContext.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+class IChainContext(ABC):
+    @property
+    @abstractmethod
+    def context(self) -> Dict[str, Any]:
+        pass
+
+    @context.setter
+    @abstractmethod
+    def context(self, value: Dict[str, Any]) -> None:
+        pass

swarmauri-0.1.124.dev4/swarmauri/core/chains/IChainContextLoader.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+class IChainContextLoader(ABC):
+    @abstractmethod
+    def load_context(self, context_id: str) -> Dict[str, Any]:
+        """Load the execution context by its identifier."""
+        pass

swarmauri-0.1.124.dev4/swarmauri/core/chains/IChainDependencyResolver.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+from typing import Tuple, Dict, List, Optional
+from swarmauri.standard.chains.concrete.ChainStep import ChainStep
+
+class IChainDependencyResolver(ABC):
+    @abstractmethod
+    def build_dependencies(self) -> List[ChainStep]:
+        """
+        Builds the dependencies for a particular sequence in the matrix.
+
+        Args:
+            matrix (List[List[str]]): The prompt matrix.
+            sequence_index (int): The index of the sequence to build dependencies for.
+
+        Returns:
+            Tuple containing indegrees and graph dicts.
+        """
+        pass
+
+    @abstractmethod
+    def resolve_dependencies(self, matrix: List[List[Optional[str]]], sequence_index: int) -> List[int]:
+        """
+        Resolves the execution order based on the provided dependencies.
+
+        Args:
+            indegrees (Dict[int, int]): The indegrees of each node.
+            graph (Dict[int, List[int]]): The graph representing dependencies.
+
+        Returns:
+            List[int]: The resolved execution order.
+        """
+        pass

swarmauri-0.1.124.dev4/swarmauri/core/prompts/IPromptMatrix.py

@@ -0,0 +1,42 @@
+# swarmauri/core/prompts/IPromptMatrix.py
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Optional, Any
+
+class IPromptMatrix(ABC):
+    @property
+    @abstractmethod
+    def matrix(self) -> List[List[Optional[str]]]:
+        """Get the entire prompt matrix."""
+        pass
+
+    @matrix.setter
+    @abstractmethod
+    def matrix(self, value: List[List[Optional[str]]]) -> None:
+        """Set the entire prompt matrix."""
+        pass
+
+    @property
+    @abstractmethod
+    def shape(self) -> Tuple[int, int]:
+        """Get the shape (number of agents, sequence length) of the prompt matrix."""
+        pass
+
+    @abstractmethod
+    def add_prompt_sequence(self, sequence: List[Optional[str]]) -> None:
+        """Add a new prompt sequence to the matrix."""
+        pass
+
+    @abstractmethod
+    def remove_prompt_sequence(self, index: int) -> None:
+        """Remove a prompt sequence from the matrix by index."""
+        pass
+
+    @abstractmethod
+    def get_prompt_sequence(self, index: int) -> List[Optional[str]]:
+        """Get a prompt sequence from the matrix by index."""
+        pass
+
+    @abstractmethod
+    def show_matrix(self) -> List[List[Optional[str]]]:
+        """Show the entire prompt matrix."""
+        pass

swarmauri-0.1.124.dev4/swarmauri/experimental/chains/IChainFormatter.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from swarmauri.core.chains.IChainStep import IChainStep
+
+class IChainFormatter(ABC):
+    @abstractmethod
+    def format_output(self, step: IChainStep, output: Any) -> str:
+        """Format the output of a specific chain step."""
+        pass

swarmauri-0.1.124.dev4/swarmauri/experimental/chains/IChainNotification.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+class IChainNotifier(ABC):
+    @abstractmethod
+    def send_notification(self, message: str) -> None:
+        """Send a notification message based on chain execution results."""
+        pass

swarmauri-0.1.124.dev4/swarmauri/experimental/chains/IChainPersistence.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+from swarmauri.core.chains.IChain import IChain
+
+class IChainPersistence(ABC):
+    @abstractmethod
+    def save_state(self, chain: IChain, state: Dict[str, Any]) -> None:
+        """Save the state of the given chain."""
+        pass
+
+    @abstractmethod
+    def load_state(self, chain_id: str) -> Dict[str, Any]:
+        """Load the state of a chain by its identifier."""
+        pass

swarmauri-0.1.124.dev4/swarmauri/experimental/chains/IChainScheduler.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from swarmauri.core.chains.IChain import IChain
+
+class IChainScheduler(ABC):
+    @abstractmethod
+    def schedule_chain(self, chain: IChain, schedule: str) -> None:
+        """Schedule the execution of the given chain."""
+        pass

swarmauri-0.1.124.dev4/swarmauri/standard/chains/base/ChainContextBase.py

@@ -0,0 +1,50 @@
+from typing import Any, Callable, Dict, List
+import re
+
+from swarmauri.core.chains.IChainContext import IChainContext
+
+class ChainContextBase(IChainContext):
+    def __init__(self):
+        self._steps = []
+        self._context = {}
+
+    @property
+    def context(self) -> Dict[str, Any]:
+        return self._context
+
+    @context.setter
+    def context(self, value: Dict[str, Any]) -> None:
+        self._context = value
+
+    def update(self, **kwargs):
+        self.state.update(kwargs)
+
+    def get_value(self, key: str) -> Any:
+        return self._context.get(key)
+
+    def _resolve_fstring(self, template: str) -> str:
+        pattern = re.compile(r'{([^}]+)}')
+        def replacer(match):
+            expression = match.group(1)
+            try:
+                return str(eval(expression, {}, self._context))
+            except Exception as e:
+                print(f"Failed to resolve expression: {expression}. Error: {e}")
+                return f"{{{expression}}}"
+        return pattern.sub(replacer, template)
+
+    def _resolve_placeholders(self, value: Any) -> Any:
+        if isinstance(value, str):
+            return self._resolve_fstring(value)
+        elif isinstance(value, dict):
+            return {k: self._resolve_placeholders(v) for k, v in value.items()}
+        elif isinstance(value, list):
+            return [self._resolve_placeholders(v) for v in value]
+        else:
+            return value
+
+    def _resolve_ref(self, value: Any) -> Any:
+        if isinstance(value, str) and value.startswith('$'):
+            placeholder = value[1:]
+            return placeholder
+        return value

swarmauri-0.1.124.dev4/swarmauri/standard/chains/base/PromptContextChainBase.py

@@ -0,0 +1,124 @@
+# swarmaurui/standard/chains/base/PromptStateChainBase.py
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+from collections import defaultdict, deque
+import re
+
+
+from swarmaurui.standard.chains.concrete.ChainStep import ChainStep
+from swarmaurui.standard.chains.base.ChainContextBase import ChainContextBase
+from swarmaurui.standard.chains.base.ChainStateBase import ChainStateBase
+from swarmaurui.core.agents.IAgent import IAgent
+from swarmaurui.core.prompts.IPromptMatrix import IPromptMatrix
+from swarmaurui.core.chains.IChainDependencyResolver import IChainDependencyResolver
+
+class PromptStateChainBase(ABC, ChainContextBase, ChainStateBase, IChainDependencyResolver):
+    def __init__(self, 
+        prompt_matrix: IPromptMatrix, 
+        agents: List[IAgent] = [], 
+        context: Dict = {},
+        model_kwargs: Dict[str, Any] = {}):
+        ChainContextBase.__init__(self)
+        ChainStateBase.__init__(self)
+        self.prompt_matrix = prompt_matrix
+        self.response_matrix = [[None for _ in range(prompt_matrix.shape[1])] for _ in range(prompt_matrix.shape[0])]
+        self.agents = agents
+        self.context = context 
+        self.model_kwargs = model_kwargs
+
+    @property
+    def context(self) -> Dict[str, Any]:
+        return self._context
+
+    @context.setter
+    def context(self, value: Dict[str, Any]) -> None:
+        self._context = value
+
+    def execute(self) -> None:
+        """
+        Execute the chain of prompts based on the state of the prompt matrix.
+        Iterates through each sequence in the prompt matrix, resolves dependencies, 
+        and executes prompts in the resolved order.
+        """
+        steps = self.build_dependencies()
+        for step in steps:
+            method = step.method
+            args = step.args
+            ref = step.ref
+            result = method(*args)
+            self.context[ref] = result
+            self._update_response_matrix(args[0], result)
+
+    def _execute_prompt(self, agent_index: int, prompt: str, ref: str):
+        """
+        Executes a given prompt using the specified agent and updates the response.
+        """
+        formatted_prompt = prompt.format(**self.context)  # Using context for f-string formatting
+        agent = self.agents[agent_index]
+        response = agent.exec(formatted_prompt, model_kwargs=self.model_kwargs)
+        self.context[ref] = response
+        self._update_response_matrix(agent_index, response)
+        return response
+
+    def _update_response_matrix(self, agent_index: int, response: Any):
+        self.response_matrix[agent_index].append(response)
+    
+    def build_dependencies(self) -> List[ChainStep]:
+        """
+        Build the chain steps in the correct order by resolving dependencies first.
+        """
+        steps = []
+        for i, sequence in enumerate(self.prompt_matrix.matrix):
+            execution_order = self.resolve_dependencies(matrix=self.prompt_matrix.matrix, sequence_index=i)
+            for j in execution_order:
+                prompt = sequence[j]
+                if prompt:
+                    ref = f"Agent_{i}_Step_{j}_response"  # Using a unique reference string
+                    step = ChainStep(
+                        key=f"Agent_{i}_Step_{j}",
+                        method=self._execute_prompt,
+                        args=[i, prompt, ref],
+                        ref=ref
+                    )
+                    steps.append(step)
+        return steps
+
+    def resolve_dependencies(self, matrix: List[List[Optional[str]]], sequence_index: int) -> List[int]:
+        """
+        Resolve dependencies within a specific sequence of the prompt matrix.
+        
+        Args:
+            matrix (List[List[Optional[str]]]): The prompt matrix.
+            sequence_index (int): The index of the sequence to resolve dependencies for.
+
+        Returns:
+            List[int]: The execution order of the agents for the given sequence.
+        """
+        indegrees = defaultdict(int)
+        graph = defaultdict(list)
+        for agent_idx, prompt in enumerate(matrix[sequence_index]):
+            if prompt:
+                dependencies = re.findall(r'\$\d+_\d+', prompt)
+                for dep in dependencies:
+                    # Extract index from the matched dependency pattern "$x_y"
+                    x = int(dep[1:])  # Remove leading "$" and convert to int
+                    graph[x].append(agent_idx)
+                    indegrees[agent_idx] += 1
+                if not dependencies:
+                    indegrees[agent_idx] = 0
+            else:
+                indegrees[agent_idx] = 0  # Ensure nodes without dependencies are in the graph
+        
+        queue = deque([idx for idx in indegrees if indegrees[idx] == 0])
+        execution_order = []
+        while queue:
+            current = queue.popleft()
+            execution_order.append(current)
+            for dependent in graph[current]:
+                indegrees[dependent] -= 1
+                if indegrees[dependent] == 0:
+                    queue.append(dependent)
+        if len(execution_order) != len(indegrees):
+            raise RuntimeError("There's a cyclic dependency or unresolved dependency in your prompt matrix.")
+        return execution_order
+

swarmauri-0.1.122.dev5/swarmauri/standard/chains/concrete/StateChain.py → swarmauri-0.1.124.dev4/swarmauri/standard/chains/concrete/ContextChain.py

@@ -1,24 +1,26 @@
+# standard/chains/concrete/ContextChain.py
 from typing import Any, Dict, List, Callable
-from swarmauri.standard.chains.base.ChainStepBase import ChainStepBase
+from swarmauri.standard.chains.base.ChainContextBase import ChainContextBase
+from swarmauri.standard.chains.base.ChainStep import ChainStep
 from swarmauri.core.chains.IChain import IChain
 
-class StateChain(IChain):
+class ContextChain(IChain, ChainContextBase):
     """
     Enhanced to support ChainSteps with return parameters, storing return values as instance state variables.
     Implements the IChain interface including get_schema_info and remove_step methods.
     """
     def __init__(self):
-        self._steps: List[ChainStepBase] = []
-        self._context: Dict[str, Any] = {}
-    
+        ChainContextBase.__init__(self)
+        self._steps: List[ChainStep] = []
+
     def add_step(self, key: str, method: Callable[..., Any], *args, ref: str = None, **kwargs):
         # Directly store args, kwargs, and optionally a return_key without resolving them
-        step = ChainStepBase(key, method, args=args, kwargs=kwargs, ref=ref)  # Note the use of 'ref' as 'return_key'
+        step = ChainStep(key, method, args=args, kwargs=kwargs, ref=ref)  # Note the use of 'ref' as 'return_key'
         self._steps.append(step)
-    
-    def remove_step(self, step: ChainStepBase) -> None:
+
+    def remove_step(self, step: ChainStep) -> None:
         self._steps = [s for s in self._steps if s.key != step.key]
-    
+
     def execute(self, *args, **kwargs) -> Any:
         # Execute the chain and manage result storage based on return_key
         for step in self._steps:
@@ -26,31 +28,15 @@ class StateChain(IChain):
             resolved_kwargs = {k: self._resolve_placeholders(v) for k, v in step.kwargs.items() if k != 'ref'}
             result = step.method(*resolved_args, **resolved_kwargs)
             if step.ref:  # step.ref is used here as the return_key analogy
-                print('step.ref', step.ref)
                 resolved_ref = self._resolve_ref(step.ref)
-                print(resolved_ref)
-                self._context[resolved_ref] = result
-        return self._context  # or any specific result you intend to return
-    
-    def _resolve_ref(self, value: Any) -> Any:
-        if isinstance(value, str) and value.startswith('$'):
-            placeholder = value[1:]
-            return placeholder
-        return value
-    
-    def _resolve_placeholders(self, value: Any) -> Any:
-        if isinstance(value, str) and value.startswith('$'):
-            placeholder = value[1:]
-            return self._context.get(placeholder)
-        return value
+                self.context[resolved_ref] = result
+                self.update(**{resolved_ref: result})  # Update context with new state value
+        return self.context  # or any specific result you intend to return
 
-    def set_context(self, **kwargs):
-        self._context.update(kwargs)
-    
     def get_schema_info(self) -> Dict[str, Any]:
         # Implementing required method from IChain; 
         # Adapt the return structure to your needs
         return {
             "steps": [step.key for step in self._steps],
-            "context_keys": list(self._context.keys())
+            "state_keys": list(self.context.keys())
         }

swarmauri-0.1.124.dev4/swarmauri/standard/chains/concrete/PromptContextChain.py

@@ -0,0 +1,13 @@
+from typing import List, Dict, Any
+from swarmauri.core.agents.IAgent import IAgent
+from swarmauri.core.prompts.IPromptMatrix import IPromptMatrix
+from swarmauri.standard.chains.base.PromptStateChainBase import PromptStateChainBase
+
+class PromptContextChain(PromptStateChainBase):
+    def __init__(self, prompt_matrix: IPromptMatrix, 
+        agents: List[IAgent] = [], context: Dict = {},
+        model_kwargs: Dict[str, Any] = {}
+        ):
+
+        PromptStateChainBase.__init__(self, prompt_matrix=prompt_matrix, agents=agents, 
+            context=context, model_kwargs=model_kwargs)

swarmauri-0.1.124.dev4/swarmauri/standard/prompts/base/BasePromptMatrix.py

@@ -0,0 +1,41 @@
+# swarmauri/standard/prompts/base/BasePromptMatrix.py
+from typing import List, Tuple, Optional, Any
+from swarmauri.core.prompts.IPromptMatrix import IPromptMatrix
+
+class BasePromptMatrix(IPromptMatrix):
+    def __init__(self):
+        self._matrix = []
+
+    @property
+    def matrix(self) -> List[List[Optional[str]]]:
+        return self._matrix
+
+    @matrix.setter
+    def matrix(self, value: List[List[Optional[str]]]) -> None:
+        self._matrix = value
+
+    def get_shape(self) -> Tuple[int, int]:
+        if self._matrix:
+            return len(self._matrix), len(self._matrix[0])
+        return 0, 0
+
+    def add_prompt_sequence(self, sequence: List[Optional[str]]) -> None:
+        if not self._matrix or (self._matrix and len(sequence) == len(self._matrix[0])):
+            self._matrix.append(sequence)
+        else:
+            raise ValueError("Sequence length does not match the prompt matrix dimensions.")
+
+    def remove_prompt_sequence(self, index: int) -> None:
+        if 0 <= index < len(self._matrix):
+            self._matrix.pop(index)
+        else:
+            raise IndexError("Index out of range.")
+
+    def get_prompt_sequence(self, index: int) -> List[Optional[str]]:
+        if 0 <= index < len(self._matrix):
+            return self._matrix[index]
+        else:
+            raise IndexError("Index out of range.")
+
+    def show_matrix(self) -> List[List[Optional[str]]]:
+        return self._matrix

swarmauri-0.1.124.dev4/swarmauri/standard/prompts/concrete/PromptMatrix.py

@@ -0,0 +1,7 @@
+# swarmauri/standard/prompts/concrete/PromptMatrix.py
+from swarmauri.standard.prompts.base.BasePromptMatrix import BasePromptMatrix
+
+class PromptMatrix(BasePromptMatrix):
+    
+    def __init__(self):
+        BasePromptMatrix.__init__(self)

swarmauri-0.1.124.dev4/swarmauri/standard/utils/json_validator.py

@@ -0,0 +1,17 @@
+# swarmauri/standard/utils/json_validator.py
+import json
+import jsonschema
+from jsonschema import validate
+
+def load_json_file(file_path: str) -> dict:
+    with open(file_path, 'r') as file:
+        return json.load(file)
+
+def validate_json(data: dict, schema_file: str) -> bool:
+    schema = load_json_file(schema_file)
+    try:
+        validate(instance=data, schema=schema)
+    except jsonschema.exceptions.ValidationError as err:
+        print(f"JSON validation error: {err.message}")
+        return False
+    return True

{swarmauri-0.1.122.dev5 → swarmauri-0.1.124.dev4}/swarmauri.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarmauri
-Version: 0.1.122.dev5
+Version: 0.1.124.dev4
 Summary: This repository includes core interfaces, standard ABCs and concrete references, third party plugins, and experimental modules for the swarmaURI framework.
 Home-page: http://github.com/swarmauri/swarmauri-sdk
 Author: Jacob Stewart

{swarmauri-0.1.122.dev5 → swarmauri-0.1.124.dev4}/swarmauri.egg-info/SOURCES.txt

@@ -44,6 +44,9 @@ swarmauri/core/agents/IAgentVectorStore.py
 swarmauri/core/agents/__init__.py
 swarmauri/core/chains/ICallableChain.py
 swarmauri/core/chains/IChain.py
+swarmauri/core/chains/IChainContext.py
+swarmauri/core/chains/IChainContextLoader.py
+swarmauri/core/chains/IChainDependencyResolver.py
 swarmauri/core/chains/IChainFactory.py
 swarmauri/core/chains/IChainStep.py
 swarmauri/core/chains/__init__.py
@@ -78,6 +81,7 @@ swarmauri/core/models/__init__.py
 swarmauri/core/parsers/IParser.py
 swarmauri/core/parsers/__init__.py
 swarmauri/core/prompts/IPrompt.py
+swarmauri/core/prompts/IPromptMatrix.py
 swarmauri/core/prompts/ITemplate.py
 swarmauri/core/prompts/__init__.py
 swarmauri/core/swarm_apis/IAgentRegistrationAPI.py
@@ -130,14 +134,10 @@ swarmauri/core/vectors/IVectorProduct.py
 swarmauri/core/vectors/IVectorTransform.py
 swarmauri/core/vectors/__init__.py
 swarmauri/experimental/__init__.py
-swarmauri/experimental/chains/ChainOrderStrategy.py
-swarmauri/experimental/chains/ChainOrderStrategyBase.py
-swarmauri/experimental/chains/ChainProcessingStrategy.py
-swarmauri/experimental/chains/ChainProcessingStrategyBase.py
-swarmauri/experimental/chains/IChainOrderStrategy.py
-swarmauri/experimental/chains/IChainProcessingStrategy.py
-swarmauri/experimental/chains/MatrixOrderStrategy.py
-swarmauri/experimental/chains/MatrixProcessingStrategy.py
+swarmauri/experimental/chains/IChainFormatter.py
+swarmauri/experimental/chains/IChainNotification.py
+swarmauri/experimental/chains/IChainPersistence.py
+swarmauri/experimental/chains/IChainScheduler.py
 swarmauri/experimental/chains/TypeAgnosticCallableChain.py
 swarmauri/experimental/chains/__init__.py
 swarmauri/experimental/conversations/ConsensusBuildingConversation.py
@@ -210,11 +210,14 @@ swarmauri/standard/apis/base/__init__.py
 swarmauri/standard/apis/concrete/__init__.py
 swarmauri/standard/chains/__init__.py
 swarmauri/standard/chains/base/ChainBase.py
+swarmauri/standard/chains/base/ChainContextBase.py
 swarmauri/standard/chains/base/ChainStepBase.py
+swarmauri/standard/chains/base/PromptContextChainBase.py
 swarmauri/standard/chains/base/__init__.py
 swarmauri/standard/chains/concrete/CallableChain.py
 swarmauri/standard/chains/concrete/ChainStep.py
-swarmauri/standard/chains/concrete/StateChain.py
+swarmauri/standard/chains/concrete/ContextChain.py
+swarmauri/standard/chains/concrete/PromptContextChain.py
 swarmauri/standard/chains/concrete/__init__.py
 swarmauri/standard/chunkers/__init__.py
 swarmauri/standard/chunkers/base/__init__.py
@@ -319,9 +322,11 @@ swarmauri/standard/parsers/concrete/URLExtractorParser.py
 swarmauri/standard/parsers/concrete/XMLParser.py
 swarmauri/standard/parsers/concrete/__init__.py
 swarmauri/standard/prompts/__init__.py
+swarmauri/standard/prompts/base/BasePromptMatrix.py
 swarmauri/standard/prompts/base/__init__.py
 swarmauri/standard/prompts/concrete/Prompt.py
 swarmauri/standard/prompts/concrete/PromptGenerator.py
+swarmauri/standard/prompts/concrete/PromptMatrix.py
 swarmauri/standard/prompts/concrete/PromptTemplate.py
 swarmauri/standard/prompts/concrete/__init__.py
 swarmauri/standard/states/__init__.py
@@ -361,6 +366,7 @@ swarmauri/standard/utils/__init__.py
 swarmauri/standard/utils/apply_metaclass.py
 swarmauri/standard/utils/decorate.py
 swarmauri/standard/utils/get_class_hash.py
+swarmauri/standard/utils/json_validator.py
 swarmauri/standard/utils/load_documents_from_json.py
 swarmauri/standard/utils/memoize.py
 swarmauri/standard/utils/sql_log.py

swarmauri-0.1.122.dev5/swarmauri/experimental/chains/ChainOrderStrategy.py

@@ -1,18 +0,0 @@
-from typing import List
-from swarmauri.core.chains.IChainOrderStrategy import IChainOrderStrategy
-from swarmauri.core.chains.IChainStep import IChainStep
-
-class ChainOrderStrategy(IChainOrderStrategy):
-    def order_steps(self, steps: List[IChainStep]) -> List[IChainStep]:
-        """
-        Orders the chain steps in reverse order.
-
-        Args:
-            steps (List[IChainStep]): The original list of chain steps to be ordered.
-
-        Returns:
-            List[IChainStep]: List of chain steps in order.
-        """
-        # Reverse the list of steps.
-        steps = list(steps)
-        return steps

swarmauri-0.1.122.dev5/swarmauri/experimental/chains/ChainOrderStrategyBase.py

@@ -1,14 +0,0 @@
-from typing import List
-from swarmauri.core.chains.IChainOrderStrategy import IChainOrderStrategy
-from swarmauri.core.chains.IChainStep import IChainStep
-
-class ChainOrderStrategyBase(IChainOrderStrategy):
-    """
-    A base implementation of the IChainOrderStrategy interface.
-    """
-
-    def order_steps(self, steps: List[IChainStep]) -> List[IChainStep]:
-        """
-        Default implementation doesn't reorder steps but must be overridden by specific strategies.
-        """
-        return steps

swarmauri-0.1.122.dev5/swarmauri/experimental/chains/ChainProcessingStrategy.py

@@ -1,21 +0,0 @@
-from typing import List, Any
-from swarmauri.core.chains.IChainProcessingStrategy import IChainProcessingStrategy
-from swarmauri.core.chains.IChainStep import IChainStep
-
-class ChainProcessingStrategy(IChainProcessingStrategy):
-    def execute_steps(self, steps: List[IChainStep]) -> Any:
-        """
-        Executes the given list of ordered chain steps based on the specific strategy 
-        and collects their results.
-
-        Args:
-            steps (List[IChainStep]): The ordered list of chain steps to be executed.
-        
-        Returns:
-            Any: The result of executing the steps. This could be tailored as per requirement.
-        """
-        results = []
-        for step in steps:
-            result = step.method(*step.args, **step.kwargs)
-            results.append(result)
-        return results

swarmauri-0.1.122.dev5/swarmauri/experimental/chains/ChainProcessingStrategyBase.py

@@ -1,16 +0,0 @@
-from typing import List
-from swarmauri.core.chains.IChainProcessingStrategy import IChainProcessingStrategy
-from swarmauri.core.chains.IChainStep import IChainStep
-
-class ChainProcessingStrategyBase(IChainProcessingStrategy):
-    """
-    A base implementation of the IChainProcessingStrategy interface.
-    """
-    
-    def execute_steps(self, steps: List[IChainStep]):
-        """
-        Default implementation which should be overridden by specific processing strategies.
-        """
-        for step in steps:
-            print(step)
-            step.method(*step.args, **step.kwargs)

swarmauri-0.1.122.dev5/swarmauri/experimental/chains/IChainOrderStrategy.py

@@ -1,9 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List
-from swarmauri.core.chains.IChainStep import IChainStep
-
-# Defines how chain steps are ordered
-class IChainOrderStrategy(ABC):
-    @abstractmethod
-    def order_steps(self, steps: List[IChainStep]) -> List[IChainStep]:
-        pass