core: creation of simple zero neuron

scopes/core/core.py

@@ -8,6 +8,7 @@ from collections.abc import Awaitable, Callable, Coroutine
 from dataclasses import dataclass, field
 from typing import Any
 
+from scopes.core import actor
 from scopes.core.message import Message
 from scopes.util import keywords as k, Symbol
 
@@ -42,6 +43,19 @@ class Scope:
         return self
 
 def create_scope(env: Mailbox, cat=(k.csys, k.c00), **kw) -> Scope:
-    scope = Scope(environ=env, categ=cat, **kw)
-    return scope.set_proc()
+    return Scope(environ=env, categ=cat, **kw)
+
+def neuron(scope: Scope) -> Mailbox:
+    async def process(msg: Message) -> actor.Behavior | None:
+        nonlocal scope
+        new_scope = await scope.proc(scope, msg)
+        if new_scope is not None:
+            scope = new_scope
+        return process
+    return actor.create(process)
+
+def create_zero(env: Mailbox) -> Mailbox:
+    scope = create_scope(env)
+    zero = neuron(scope)
+    return zero
 

scopes/core/environ.py

@@ -8,7 +8,9 @@ from scopes.util import keywords as k
 
 async def proc_env(scope, msg):
     await scope.environ.put(msg)
+    #return scope
 
 def create(meta_env):
-    return core.create_scope(meta_env, (k.env, k.c00), program=lambda x: proc_env)
+    scope = core.create_scope(meta_env, (k.env, k.c00), program=lambda x: proc_env)
+    return core.neuron(scope)
 

tests/test_core.py

@@ -6,37 +6,41 @@ import asyncio
 import pytest
 
 from scopes import core
-from scopes.core import actor, environ, message
+from scopes.core import actor, environ
+from scopes.core.message import Message
 from scopes.util import keywords as k
 
-collector = []
-
-def show(msg):
-    collector.append(msg)
+@pytest.fixture
+def collector():
+    return []
 
 
-async def handle_basic(msg):
+def show(msg, coll):
+    coll.append(msg)
+
+def handle_basic(coll):
+    async def handle(msg):
         match msg:
-        case k.show: show(msg)
-        case k.switch: return handle_alt
-        case _: show(msg)
+          case k.show: show(msg, coll)
+          case k.switch: return handle_alt(coll)
+          case _: show(msg, coll)
+    return handle
 
-async def handle_alt(msg):
+def handle_alt(coll):
+    async def handle(msg):
         match msg:
-        case k.show: show('switched')
-        case _: await asyncio.sleep(0.01); show(msg)
+          case k.show: show('switched', coll)
+          case _: await asyncio.sleep(0.01); show(msg, coll)
+    return handle
 
 
 @pytest.mark.anyio
-async def test_actor():
+async def test_actor(collector):
     async with asyncio.TaskGroup() as group:
-        q1 = actor.create(handle_basic, group)
-        q2 = actor.create(handle_basic, group)
-        await q1.put(message.Message(k.test, k.hello))
-        await q1.put(k.show)
-        await q1.put(k.switch)
-        await q1.put(k.show)
-        await q1.put("actor 1: Goodbye")
+        q1 = actor.create(handle_basic(collector), group)
+        q2 = actor.create(handle_basic(collector), group)
+        msgs = [Message(k.test, k.hello), k.show, k.switch, k.show, "actor 1: Goodbye"]
+        await asyncio.gather(*[q1.put(m) for m in msgs])
         await q2.put("actor 2")
         await q2.put(k.show)
         await q1.put(k.quit)
@@ -47,7 +51,7 @@ async def test_actor():
 
 
 def test_message():
-    msg = message.Message(k.test, k.data, 'person', '4711', 
+    msg = Message(k.test, k.data, 'person', '4711', 
                   data=dict(firstName='Bob', lastName='Miller'))
     assert msg.head['class'] is k.person
     assert msg.addr() == (k.test, k.person, '4711')
@@ -55,19 +59,22 @@ def test_message():
 
 
 @pytest.fixture
-def coll():
-    return []
-
-@pytest.fixture
-async def meta_env(coll):
+async def meta_env(collector):
     async def collect(msg):
-        coll.append(msg)
+        collector.append(msg)
     return actor.create(collect)
 
 @pytest.mark.anyio
-async def test_core(meta_env, coll):
-    env_scope = environ.create(meta_env)
-    assert env_scope.value == 0
-    #print(meta_env)
+async def test_core(meta_env, collector):
+    env = environ.create(meta_env)
+    await env.put(Message(k.env, k.hello))
     await asyncio.sleep(0.01)
+    assert len(collector) == 1
+    assert collector[0].domain is k.env
+    zero = core.create_zero(env)
+    await zero.put(Message(k.csys, k.hello))
+    await asyncio.sleep(0.01)
+    assert len(collector) == 2
+    assert collector[1].domain is k.csys
+    #print(collector)