adding remote state experiments

Author: chris-aeviator

examples/stateful_create_actor.py

@@ -0,0 +1,52 @@
+
+# create_actor.py
+import ray
+
+@ray.remote
+class StatefulActor:
+    def __init__(self):
+        self.state = {}
+        self.invocation_count = 0
+
+    def set_value(self, key, value):
+        self.state[key] = value
+
+    def get_value(self, key):
+        return self.state.get(key, None)
+
+    def foobar(self):
+        self.invocation_count +=1  
+        print("_______FOOOBAR________")
+        print(self.invocation_count)
+        self.set_value('invocation_count', self.invocation_count + 1)
+        return "foobar"
+
+    # Use __setattr__ to set values dynamically
+    def __setattr__(self, key, value):
+        if key == 'state':  # Ensure the actual state is set normally
+            super().__setattr__(key, value)
+        else:
+            self.state[key] = value  # Set the key-value pair in the state
+
+    # Use __getattr__ to get values dynamically
+    def __getattr__(self, key):
+        return self.get_value(key)
+
+
+# Initialize Ray and specify a namespace for easier reconnection
+ray.init()
+
+# Create a detached actor under the namespace "my_namespace"
+actor = StatefulActor.options(
+    name="stateful_actor", 
+    lifetime="detached", 
+    namespace="pymc-stateful-actor-dev"
+).remote()
+
+# Set some initial state
+actor.set_value.remote("key1", "initial_value")
+
+# Print the value to confirm it works
+print(ray.get(actor.get_value.remote("key1")))  # Outputs: initial_value
+
+# You can now safely exit this program

examples/stateful_create_actorv2.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import ray
+
+"""
+@ray.remote
+class StatefulActor:
+    def __init__(self):
+        super().__setattr__("state", {})  # Initialize state
+
+    def __setattr__(self, key, value):
+        print('key: '+ key + ', value:', value)
+        if key.startswith('_') or key == 'state':
+            super().__setattr__(key, value)
+        else:
+            # Set the value using remote call
+            ray.get(self.set_value.remote(key, value))
+
+    def __getattr__(self, key):
+        print(key)
+        # Dynamically fetch the value from the actor's state
+        if key.startswith('_') or key == 'state':
+            raise AttributeError(f"Attribute '{key}' not found")  # Avoid infinite loop
+
+        return ray.get(self.get_value.remote(key))
+
+    def foobar(self):
+        self.invocation_count +=1  
+        print("_______FOOOBAR________")
+        print(self.invocation_count)
+        #self.set_value('invocation_count', self.invocation_count + 1)
+        return "foobar"
+
+    def set_value(self, key, value):
+        self.state[key] = value
+
+    def get_value(self, key):
+        return self.state.get(key, None)
+
+"""
+import ray
+
+@ray.remote
+class StatefulActor:
+    def __init__(self):
+        # Initialize internal state attributes
+        self._state = {}  # Use a private variable for dynamic attributes
+        self.invocation_count = 0  # Internal state attribute
+
+    """
+    def __setattr__(self, key, value):
+        print('set', key, value)
+        # Allow normal assignment for internal attributes
+        if '_' in key:
+            # Directly set internal state attributes
+            super().__setattr__(key, value)
+        else:
+            # Store dynamic attributes in the _state dictionary
+            self._state[key] = value
+
+    def __getattr__(self, key):
+        print('get', key)
+        # Allow normal retrieval for internal attributes
+        if '_' in key:
+            return super().__getattribute__(key)
+        # Return from dynamic state
+        return self._state.get(key, None)
+    """
+
+    def foobar(self):
+        # Increment invocation_count normally
+        print('will halt')
+        breakpoint()
+        self.invocation_count += 1
+        return self.invocation_count
+
+    def get_invocation_count(self):
+        return self.invocation_count
+
+    def get_dynamic_value(self, key):
+        return self._state.get(key, None)
+
+
+# Initialize Ray
+ray.init(
+    runtime_env={
+        "env_vars": {"RAY_DEBUG": "1"},
+    }
+)
+
+# Create a detached actor under the namespace "my_namespace"
+actor = StatefulActor.options(
+    name="stateful_actor", 
+    lifetime="detached", 
+    namespace="my_namespace"
+).remote()
+
+#  breakpoint()
+"""
+# Use the abstracted way to set and get values dynamically
+actor.key1 = 'value1'  # Abstracted assignment
+print(ray.get(actor.key1))  # Outputs: value1
+
+actor.key2 = 'value2'
+print(ray.get(actor.key2))  # Outputs: value2
+
+"""
+ray.shutdown()
+

examples/stateful_kill_actor.py

@@ -0,0 +1,14 @@
+import ray
+# Reconnect to Ray with the same namespace
+ray.init()
+# Get the actor from the namespace "my_namespace"
+try:
+    actor = ray.get_actor("stateful_actor", namespace="pymc-stateful-actor-dev")
+    ray.kill(actor)
+except:
+    pass
+try:
+    actor = ray.get_actor("stateful_actor", namespace="my_namespace")
+    ray.kill(actor)
+except:
+    pass

examples/stateful_reconnect_actorv2.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+import ray
+# -*- coding: utf-8 -*-
+
+
+ray.init(namespace="my_namespace")
+# Get the actor from the namespace "my_namespace"
+actor = ray.get_actor("stateful_actor")
+remote_val = actor.foobar.remote()
+print(ray.get(remote_val))
+
+#assert  remote_val == 'bar'
+
+"""
+# Use the abstracted way to set and get values dynamically
+actor.key1 = 'value1'  # Abstracted assignment
+print(ray.get(actor.key1))  # Outputs: value1
+
+actor.key2 = 'value2'
+print(ray.get(actor.key2))  # Outputs: value2
+"""
+
+ray.shutdown()

examples/stateful_reconnect_to_actor.py

@@ -0,0 +1,32 @@
+# reconnect_actor.py
+import ray
+
+# Reconnect to Ray with the same namespace
+ray.init(namespace="pymc-stateful-actor-dev")
+
+# Get the actor from the namespace "my_namespace"
+actor = ray.get_actor("stateful_actor")
+# Get the previous state
+print(ray.get(actor.get_value.remote("key1")))  # Outputs: initial_value
+print(ray.get(actor.get_value.remote("key2")))  # Outputs: initial_value
+
+print("-----")
+# Set new state
+actor.set_value.remote("key2", "new_value")
+
+# Get the new state
+print(ray.get(actor.get_value.remote("key2")))  # Outputs: new_value
+print("-----")
+
+
+### foobar
+r = actor.foobar.remote()
+print(ray.get(r))
+
+r = actor.foobar.remote()
+print(ray.get(r))
+
+
+invocation_count = ray.get(actor.get_value.remote('invocation_count'))
+print(invocation_count)  # Outputs: new_value
+