Merge pull request 'impl/client-server/simple-remote-state' (#11) from impl/client-server/simple-remote-state into main

Reviewed-on: https://git.myzel.io/PyMC/PyMC-Server/pulls/11

Author: chris-aeviator

README.md

@@ -3,7 +3,14 @@
 ## what does it do
 
 The Tool will be used to deploy on skypilot. It aims to simplify the deployment process. 
-In the end, the application needs to merge different .yaml files (pyMc-/user Files) together 
+In the end, the application needs to merge different .yaml files (pyMc-/user Files) together.
+
+The library can be used and configured in 3 forms
+
+- via a Python API and by passing configuration as parameters
+- via the CLI and YAML files for configuration
+- via the CLI and command line parameters for configuration.
+ 
 # Quickstart
 
 ## Installation
@@ -25,7 +32,7 @@ cd PyMC-Server
 pip3 install . # run `pip3 install -e .` if you want to be able to edit the code
 ```
 
-### Setting up a cloud: Google Cloud
+## Setting up a cloud: Google Cloud
 
 1. Run `pymcs check` to see if you already have credentials setup. If you see a green checkmark for GCP (Google Cloud Platform), skip to the next section
 2. Install the google cloud SDK and authenticate.
@@ -53,7 +60,7 @@ pip3 install . # run `pip3 install -e .` if you want to be able to edit the code
 
   Next, create a new role and name it e.g. `pymcs-server-role`.
 
-  >Note: we will be granting overly permissive rules for convenience of your setup not taking too long.
+  >Note: we will be granting overly permissive rules for convenience of your setup.
   >For production usage it is strictly neccessary that you review the permissions given. Please refer to [GCP: Minimal Permissions](https://skypilot.readthedocs.io/en/latest/cloud-setup/cloud-permissions/gcp.html#minimal-permissions) for more information on how to setup secure and fine grained permissions.
 
   Add the following permissions to your newly created role. At the time of writing this document Google offers a search bar where each permission needs to be entered. The table below the search bar will display the roles under this name, and you can select them all together with the first checkbox in the table (header).
@@ -71,7 +78,12 @@ roles/iam.securityAdmin
 
   >Note: If you use PyMC-Server as part of an organization, your GCP admin might have setup a role already (e.g. `pymc-server-role `) and you can easily attach your user to it.
 
-### Status of your deployments
+# Yaml configuration
+# Command Line Usage 
+## Start a new single or multi-node cluster (with YAML configuration)
+Setup a configuration file (see #Yaml-configuration)
+## Start a new single or multi-node cluster (with CLI parameter configuration)
+## Status of your deployments
 
 To check the status of all your deployments run `pymcs status`. A table is printed to your terminal.
 

examples/cluster/dev.yaml

@@ -8,7 +8,7 @@ resources:
   ports : 80
 
 workdir: ./src/pymc_server/workDir_test
-pymc_module: pymc-marketing
+module_name: pymc-marketing
 run: |
   echo "Hello, SkyPilot!"
   uname -a

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
+

requirements.txt

@@ -1,4 +1,3 @@
-pymc-marketing
 nutpie
 lifetimes
 numba

src/pymc_server/cli.py

@@ -2,17 +2,20 @@
 import sky
 from typing import Any, Dict, List, Optional, Tuple, Union
 from pymc_server.utils.yaml import merge_yaml
-from pymc_server.launch_cli import launch as cli_launch
+#from pymc_server.commands.launch_cli import launch as cli_launch,cli_launch_
+from pymc_server.commands.launch_cli import launch_2
+from pymc_server.commands.down_cli import down as down_cli
 from pymc_server.cli_factory import setup_launch_factory, setup_status_factory
 from sky.usage import usage_lib
+from sky.cli import _get_shell_complete_args, _get_click_major_version, _complete_cluster_name, _NaturalOrderGroup, _DocumentedCodeCommand
+
 
 
 from sky.cli import (
     status as sky_status,
     launch as sky_launch,
     check as sky_check
 )
-   
 
 # TODO: remove, check pyproject.py for a reference to this function
 @click.group()
@@ -24,7 +27,12 @@ def cli():
 def status(*args, **kwargs):
     """ calls the sky status command by passing the click context"""
     ctx = click.get_current_context()
-    ctx.invoke(sky_status, *args, **kwargs)
+    #ctx.invoke(_status_test, *args, **kwargs)
+    print("*args",*args)
+    data = ctx.invoke(sky_status, *args, **kwargs)
+    #print("DATA",data)
+
+    #ctx.invoke(sky_status, *args, **kwargs)
 
 
 @setup_launch_factory
@@ -40,7 +48,8 @@ def launch(*args, **kwargs):
     """
     #  cli_launch(*args, **kwargs)
     ctx = click.get_current_context()
-    ctx.invoke(cli_launch, *args, **kwargs)
+    ctx.invoke(launch_2, *args, **kwargs)
+    #ctx.invoke(sky_launch, *args, **kwargs)
 
 @setup_status_factory
 @usage_lib.entrypoint
@@ -51,6 +60,43 @@ def check(*args, **kwargs):
     ctx.invoke(sky_check, *args, **kwargs)
 
 
+@cli.command(cls=_DocumentedCodeCommand)
+@click.argument('clusters',
+                nargs=-1,
+                required=False,
+                **_get_shell_complete_args(_complete_cluster_name))
+@click.option('--all',
+              '-a',
+              default=None,
+              is_flag=True,
+              help='Tear down all existing clusters.')
+@click.option('--yes',
+              '-y',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Skip confirmation prompt.')
+@click.option(
+    '--purge',
+    '-p',
+    is_flag=True,
+    default=False,
+    required=False,
+    help=('(Advanced) Forcefully remove the cluster(s) from '
+          'SkyPilot\'s cluster table, even if the actual cluster termination '
+          'failed on the cloud. WARNING: This flag should only be set sparingly'
+          ' in certain manual troubleshooting scenarios; with it set, it is the'
+          ' user\'s responsibility to ensure there are no leaked instances and '
+          'related resources.'))
+@usage_lib.entrypoint
+def down(*args, **kwargs):
+    ctx = click.get_current_context()
+    #sky_check(*args, **kwargs)
+    ctx.invoke(down_cli, *args, **kwargs)
+    """Deletes a local cluster."""
+
+
+
 cli.add_command(status)
 cli.add_command(launch)
 cli.add_command(check)