core, work in progress: basic actions, env notifications

scopes/core/core.py

@@ -13,10 +13,10 @@ from scopes.core.message import Message
 from scopes import util
 from scopes.util import keywords as k, Symbol, Symbols
 
-# keywords (domains, actions, categories, stages, data keys):
+# keywords (domains, actions, classes, stages, data keys):
-k('csys env',
+k('csys ctl env',
-  'connect create created data default value',
+  'connect create created data default query set value',
-  'c00 e00 s00',
+  'c00 e00 s00 rcvr op',
   'initial active retired',
   'address pred succ')
 
@@ -52,7 +52,7 @@ def synapse(rcvr: Mailbox, op: SynOp = lambda x: x) -> Syn:
 env_dummy: Mailbox = asyncio.Queue()
 
 def notify() -> Handler:
-    async def handle(msg, scope) -> None:
+    async def handle(msg: Message, scope: Scope) -> None:
         await scope.environ.put(msg)
     return handle
 
@@ -118,27 +118,33 @@ async def create_zero(env: Mailbox) -> Mailbox:
 # predefined action handlers and Action sets
 
 def forward() -> Handler:
-    async def handle(msg, scope) -> None:
+    async def handle(msg: Message, scope: Scope) -> None:
         for syn in scope.syns:
             await syn(msg)
     return handle
 
 def value_add() -> Handler:
-    async def handle(msg, scope) -> tuple[Message, Scope]:
+    async def handle(msg: Message, scope: Scope) -> tuple[Message, Scope]:
         return msg, scope
     return handle
 
 def create() -> Handler:
-    async def handle(msg, scope) -> None:
+    async def handle(msg: Message, scope: Scope) -> None:
         new = neuron(clone_scope(scope, **msg.data))
         await notify_created(msg, new, scope)
+        conn = msg.data.get(k.connect)
+    return handle
+
+def connect() -> Handler:
+    async def handle(msg: Message, scope: Scope) -> None:
         return None
     return handle
 
 def basic_actions() -> Actions:
     acts: Actions = {
         k.value: value_add(),
-        k.create: create()
+        k.create: create(),
+        k.connect: connect()
     }
     return acts
 
@@ -147,7 +153,8 @@ def basic_actions() -> Actions:
 def std_proc(actions: Actions | None = None, finalize: Handler = forward(), 
              more: Actions = {}) -> Proc:
     if actions is None:
-        actions = basic_actions() | more
+        actions = basic_actions()
+    actions.update(more)
     return gen_proc(actions, finalize=finalize)
 
 # helpers

scopes/core/environ.py

@@ -7,8 +7,22 @@ from scopes.core import actor
 from scopes.core.message import Message
 from scopes.util import keywords as k
 
-def create(meta_env: core.Mailbox) -> core.Mailbox:
+def create_env(meta_env: core.Mailbox) -> core.Mailbox:
     scope = core.create_scope(meta_env, (k.env, k.c00), 
-                              program=core.gen_program({}))
+                              program=core.gen_program({}, default=env_proc()))
     return core.neuron(scope)
 
+def env_proc() -> core.Proc:
+    return core.gen_proc(env_actions(), default=None, finalize=core.notify())
+
+def handle_created() -> core.Handler:
+    async def handle(msg: Message, scope: core.Scope) -> Message:
+        return msg
+    return handle
+
+def env_actions() -> core.Actions:
+    return {
+        k.created: handle_created(),
+    }
+
+

tests/test_core.py

@@ -67,7 +67,7 @@ async def meta_env(collector):
 
 @pytest.mark.anyio
 async def test_core(meta_env, collector):
-    env = environ.create(meta_env)
+    env = environ.create_env(meta_env)
     zero = await core.create_zero(env)
     await env.put(Message(k.env, k.hello))
     await zero.put(Message(k.csys, k.hello))

tests/test_util.py

@@ -11,11 +11,15 @@ k('dummy other', 'cd', 'new', 'erp')
 dom = Symbols('dom')('crm erp sys')
 
 def test_keywords():
+    assert k.dummy == 'dummy'
+    assert k.dummy is not 'dummy'
     assert k.dummy is k.dummy
     assert k.dummy is not k.other
     assert getattr(k, "abcd"[-2:]) is k.cd
     assert k['dummy'] is k.dummy
     assert k['new'] is k['new']
+    assert dom.erp == 'dom.erp'
+    assert dom.erp is not 'dom.erp'
     assert repr(dom.erp) == '<dom.erp>'
     assert dom.erp != k.erp