Implementing py-tuple py-list py-dict py-chain

python/hyperon/stdlib.py

@@ -3,7 +3,7 @@
 import os
 
 from .atoms import ExpressionAtom, E, GroundedAtom, OperationAtom, ValueAtom, NoReduceError, AtomType, MatchableObject, \
-    G, S, Atoms
+    G, S, Atoms, ValueObject, OperationObject
 from .base import Tokenizer, SExprParser
 from .ext import register_atoms, register_tokens
 import hyperonpy as hp
@@ -212,3 +212,52 @@ def load_ascii_atom(space, name):
     return {
         r"load-ascii": loadAtom
     }
+
+def groundedatom_to_python_object(a):
+    obj = a.get_object()
+    if isinstance(obj, ValueObject):
+        obj = obj.value
+    if isinstance(obj, OperationObject):
+        obj = obj.content
+    return obj
+
+# convert nested tuples to nested python tuples or lists
+def _py_tuple_list(tuple_list, *atoms):
+    rez = []
+    for a in atoms:
+        if isinstance(a, GroundedAtom):
+            rez.append(groundedatom_to_python_object(a))
+        elif isinstance(a, ExpressionAtom):
+            rez.append(_py_tuple_list(tuple_list, *a.get_children()))
+    return tuple_list(rez)
+
+def py_tuple(*atoms):
+    return [ValueAtom(_py_tuple_list(tuple, *atoms))]
+
+def py_list(*atoms):
+    return [ValueAtom(_py_tuple_list(list, *atoms))]
+
+def tuple_to_keyvalue(a):
+    ac = a.get_children()
+    if len(ac) != 2:
+        raise Exception("Syntax error in tuple_to_keyvalue")
+    return groundedatom_to_python_object(ac[0]), groundedatom_to_python_object(ac[1])
+
+# convert pair of tuples to python dictionary
+def py_dict(*atoms):
+    return [ValueAtom(dict([tuple_to_keyvalue(a) for a in atoms]))]
+
+# chain python objects with |  (syntactic sugar for langchain)
+def py_chain(*atoms):
+    objects = [groundedatom_to_python_object(a) for a in atoms]
+    result = objects[0]
+    for obj in objects[1:]:
+        result = result | obj
+    return [ValueAtom(result)]
+
+@register_atoms()
+def py_funs():
+    return {"py-tuple": OperationAtom("py-tuple",  py_tuple, unwrap = False),
+            "py-list": OperationAtom("py-list",    py_list, unwrap = False),
+            "py-dict":  OperationAtom("py-dict",   py_dict,  unwrap = False),
+            "py-chain":  OperationAtom("py-chain", py_chain, unwrap = False)}

python/sandbox/simple_import/example_01.metta

@@ -1,11 +1,10 @@
-!(import! &self simple_import)
-
-!(import_from example_01 import simple_fun)
-!(import_from example_01 import SimpleObject)
+!(bind! simple_fun (py-atom example_01.simple_fun))
+!(bind! SimpleObject (py-atom example_01.SimpleObject))
 
 !(bind! so (SimpleObject))
 
+
 ; it is important that obj will have type SimpleObject when passed to simple_fun!
-!(simple_fun 1 2 "3" (kwarg1 2) (obj so) )
+!(simple_fun 1 2 "3" (Kwargs (kwarg1 2) (obj so)) )
 
-!(call_dot so method "arg1" "arg2" (arg3 3))
+!( (py-dot so method) "arg1" "arg2" (Kwargs (arg3 3)) )

python/sandbox/simple_import/example_02_numpy.metta

@@ -1,18 +1,16 @@
-!(import! &self simple_import)
+!(bind! np (py-atom numpy))
 
-!(import_as numpy as np)
+!(bind! a1 ( (py-dot np array) (py-atom (py-tuple 1 2 3) )))
+!(bind! a2 ( (py-dot a1 __mul__) 3))
+!(bind! a3 ( (py-dot a1 __add__) a2))
 
-!(bind! a1 (call_dot np array (ptuple 1 2 3) ))
-!(bind! a2 (call_dot a1 __mul__ 3))
-!(bind! a3 (call_dot a1 __add__ a2))
 
+!(a1)
+!(a2)
+!(a3)
 
-!(__unwrap a1)
-!(__unwrap a2)
-!(__unwrap a3)
+!(bind! m1 ((py-dot np array) (py-atom (py-list (1 2 3) (py-list 4 4 5) (py-tuple 6 7 8)) )))
+!(bind! linalg (py-atom numpy.linalg))
+!(bind! m1_inv ( (py-dot linalg inv) m1))
 
-!(bind! m1 (call_dot np array (ptuple (1 2 3) (4 4 5) (6 7 8)) ))
-!(import_as numpy.linalg as linalg)
-!(bind! m1_inv (call_dot linalg inv m1))
-
-!(__unwrap (call_dot np matmul m1 m1_inv))
+!( (py-dot np matmul) m1 m1_inv)

python/sandbox/simple_import/example_03_langchain.metta

@@ -1,21 +1,18 @@
-!(import! &self simple_import)
+!(bind! ChatOpenAI (py-atom langchain_openai.ChatOpenAI))
+!(bind! ChatPromptTemplate (py-atom langchain_core.prompts.ChatPromptTemplate))
+!(bind! StrOutputParser (py-atom langchain_core.output_parsers.StrOutputParser))
 
-!(import_from langchain_openai import ChatOpenAI)
-!(import_from langchain_core.prompts import ChatPromptTemplate)
-!(import_from langchain_core.output_parsers import StrOutputParser)
+!(bind! model (ChatOpenAI (Kwargs (temperature 0) (model "gpt-3.5-turbo"))))
 
+!(bind! prompt ( (py-dot ChatPromptTemplate from_template) "tell me a joke about cat"))
 
-!(bind! model (ChatOpenAI (temperature 0) (model "gpt-3.5-turbo")))
+!(bind! chain1 (py-chain  prompt model (StrOutputParser) ))
 
-!(bind! prompt (call_dot ChatPromptTemplate from_template "tell me a joke about cat"))
+!( (py-dot chain1 invoke) (py-dict))
 
-!(bind! chain1 (chain prompt model (StrOutputParser) ))
+!(bind! prompt2 ( (py-dot ChatPromptTemplate from_messages ) (py-tuple ("system" "You are very funny") ("user" "tell me joke about {foo}"))))
 
-!(__unwrap(call_dot chain1 invoke (pdict)))
+!(bind! chain2 (py-chain prompt2 model (StrOutputParser) ))
 
-!(bind! prompt2 (call_dot ChatPromptTemplate from_messages (ptuple ("system" "You are very funny") ("user" "tell me joke about {foo}"))))
-
-!(bind! chain2 (chain prompt2 model (StrOutputParser) ))
-
-!(__unwrap(call_dot chain2 invoke (pdict (foo "dogs") )))
+!((py-dot chain2 invoke) (py-dict ("foo" "dogs")))
 

python/sandbox/simple_import/example_04_numpy_simple_import.metta

@@ -1,14 +1,6 @@
-!(import! &self simple_import)
+!(bind! linalg (py-atom numpy.linalg))
+!(bind! numpy (py-atom numpy))
 
-; with simple "import" it is rather common that we import something
-; twice because of submodules in python
-; So let's import twice to make sure that it does not cause any problems
-!(import numpy)
-!(import numpy)
-!(import numpy.linalg)
-
-
-!(bind! m1 (call_dot2 numpy random rand 3 3 ))
-!(bind! m1_inv (call_dot2 numpy linalg inv m1))
-
-!(__unwrap (call_dot numpy matmul m1 m1_inv))
+!(bind! m1 ((py-dot numpy random.rand) 3 3 ))
+!(bind! m1_inv ( (py-dot linalg inv) m1))
+!( (py-dot numpy matmul) m1 m1_inv)