Fix. Invoke and update readme

Author: sleipnir

README.md

@@ -1,29 +1,134 @@
 # Spawn Python SDK
-
 Python User Language Support for [Spawn](https://github.com/eigr/spawn).
 
-## Installation via source
+# Table of Contents
+1. [Overview](#overview)
+2. [Getting Started](#getting-started)
+
+
+## Overview
+TODO
+
+## Getting Started
+
+First we must create a new Python project. In this example we will use [Poetry](https://python-poetry.org) as our package manager.
 
+```shell
+poetry new spawn-py-demo
 ```
-> git clone https://github.com/eigr-labs/spawn-python-sdk.git
-Cloning into 'spawn-python-sdk'...
 
-> cd spawn-python-sdk
-> python3 -m venv env 
-> source ./env/bin/activate
-> python --version     
-Python 3.7.3
-> pip --version 
-> pip install wheel
-> pip install .
+The second thing we have to do is add the spawn dependency to the project.
+
+```toml
+[tool.poetry.dependencies]
+python = ">=3.9.7,<4.0"
+spawn = {git = "https://github.com/eigr/spawn-python-sdk.git"}
 ```
 
-### Generate installer
+Now it is necessary to download the dependencies via Poetry:
+
+```shell
+poetry env use python3 # use your own python here
+poetry lock
+poetry install
+```
+
+So far it's all pretty boring and not really Spawn related so it's time to start playing for real.
+The first thing we're going to do is define a place to put our protobuf files. In the root of the project we will create a folder called protobuf and some subfolders
+
+```shell
+mkdir -p spawn_py_demo/protobuf/domain
 ```
-python setup.py bdist_wheel
+
+That done, let's create our protobuf file inside the example folder.
+
+```shell
+touch spawn_py_demo/protobuf/domain/domain.proto
+```
+
+And let's populate this file with the following content:
+
+```proto
+syntax = "proto3";
+
+package domain;
+
+message JoeState {
+  repeated string languages = 1;
+}
+
+message Request {
+  string language = 1;
+}
+
+message Reply {
+  string response = 1;
+}
 ```
 
-### Local install
+We must compile this file using the protoc utility. In the root of the project type the following command:
+
+```shell
+protoc -I spawn_py_demo/protobuf/ --python_out=spawn_py_demo spawn_py_demo/protobuf/domain/domain.proto
+```
+
+Now in the spawn_py_demo folder we will create our first python file containing the code of our Actor.
+
+```shell
+touch spawn_py_demo/joe.py
+```
+
+Populate this file with the following content:
+
+```python
+from domain.domain_pb2 import JoeState, Request, Reply
+from spawn.eigr.functions.actors.api.actor import Actor
+from spawn.eigr.functions.actors.api.settings import ActorSettings
+from spawn.eigr.functions.actors.api.context import Context
+from spawn.eigr.functions.actors.api.value import Value
+from spawn.eigr.functions.actors.api.workflows.broadcast import Broadcast
+
+actor = Actor(settings=ActorSettings(
+    name="joe", stateful=True, channel="test"))
+
+
+@actor.timer_action(every=1000)
+def hi(ctx: Context) -> Value:
+    new_state = None
+    request = Request()
+    request.language = "python"
+    broadcast = Broadcast()
+    broadcast.channel = "test"
+    broadcast.action_name = "setLanguage"
+    broadcast.value = request
+
+    if not ctx.state:
+        new_state = JoeState()
+        new_state.languages.append("python")
+    else:
+        new_state = ctx.state
+
+    return Value()\
+        .broadcast(broadcast)\
+        .state(new_state)\
+        .noreply()
+
+
+@actor.action("setLanguage")
+def set_language(request: Request, ctx: Context) -> Value:
+    reply = Reply()
+    reply.response = "erlang"
+    return Value().of(reply, ctx.state).reply()
+```
+
+Now with our Actor properly defined, we just need to start the SDK correctly. Create another file to serve as your application's entrypoint and fill it with the following content:
+
+```python
+from spawn.eigr.functions.actors.api.sdk import Spawn
+from joe import actor as joe_actor
+
+if __name__ == "__main__":
+    spawn = Spawn()
+    spawn.port(8091).proxy_port(9003).actor_system(
+        "spawn-system").add_actor(joe_actor).start()
 ```
-python -m pip install dist/spawn-python-sdk-0.1.0-py3-none-any.whl
-```

example/joe.py

@@ -6,41 +6,37 @@
 from spawn.eigr.functions.actors.api.actor import Actor
 from spawn.eigr.functions.actors.api.settings import ActorSettings
 from spawn.eigr.functions.actors.api.context import Context
-from spawn.eigr.functions.actors.api.metadata import Metadata
 from spawn.eigr.functions.actors.api.value import Value
 from spawn.eigr.functions.actors.api.workflows.broadcast import Broadcast
-from spawn.eigr.functions.actors.api.workflows.effect import Effect
 
-actor = Actor(settings=ActorSettings(name="joe", stateful=True))
+actor = Actor(settings=ActorSettings(
+    name="joe", stateful=True, channel="test"))
 
 
 @actor.timer_action(every=1000)
 def hi(ctx: Context) -> Value:
     new_state = None
+    request = Request()
+    request.language = "python"
     broadcast = Broadcast()
     broadcast.channel = "test"
     broadcast.action_name = "setLanguage"
-    broadcast.value = Request()
+    broadcast.value = request
 
     if not ctx.state:
         new_state = JoeState()
-        new_state.languages.append("portuguese")
+        new_state.languages.append("python")
     else:
         new_state = ctx.state
 
     return Value()\
-        .of("test")\
         .broadcast(broadcast)\
         .state(new_state)\
-        .reply()
+        .noreply()
 
 
 @actor.action("setLanguage")
 def set_language(request: Request, ctx: Context) -> Value:
-    return Value()\
-        .of("test")\
-        .broadcast()\
-        .effect(Effect())\
-        .metada(Metadata())\
-        .state({})\
-        .reply()
+    reply = Reply()
+    reply.response = "erlang"
+    return Value().of(reply, ctx.state).reply()

spawn/eigr/functions/actors/api/actor.py

@@ -63,20 +63,18 @@ def register_timer_action_handler(function):
 
 
 def invoke(function, parameters):
-    ordered_parameters = []
     for parameter_definition in inspect.signature(function).parameters.values():
         annotation = parameter_definition.annotation
+
         if annotation == inspect._empty:
             raise Exception("Cannot inject parameter {} of function {}: Missing type annotation".format(
                 parameter_definition.name, function))
-        match_found = False
-        for param in parameters:
-            if isinstance(param, annotation):
-                match_found = True
-                ordered_parameters.append(param)
-        if not match_found:
-            raise Exception("Cannot inject parameter {} of function {}: No matching value".format(
-                parameter_definition.name, function))
+
+    ordered_parameters = []
+    for param in parameters:
+        if param != None:
+            ordered_parameters.append(param)
+
     return function(*ordered_parameters)
 
 

spawn/eigr/functions/actors/internal/controller.py

@@ -97,9 +97,9 @@ def handle_response(system, actor_name, result):
     actor_invocation_response.updated_context.CopyFrom(updated_context)
 
     if result.get_reply_kind() == ReplyKind.NO_REPLY:
-        actor_invocation_response.noop = Noop()
+        actor_invocation_response.noop.CopyFrom(Noop())
     elif result.get_reply_kind == ReplyKind.REPLY:
-        actor_invocation_response.value = pack(result.get_response())
+        actor_invocation_response.value.CopyFrom(pack(result.get_response()))
 
     if result.get_broadcast() != None:
         value_broadcast = result.get_broadcast()