Added basic implentation for where

src/core/utils.py

@@ -1,6 +1,7 @@
 import importlib
 import inspect
 import pkgutil
+import re
 
 from core.tokenizer import TokenKind
 
@@ -239,43 +240,6 @@ def pp(items):
     return "    \n" + "    \n".join(str(item) for item in items)
 
 
-def decode_concept(concept_repr):
-    """
-    if concept_repr is like :c:key:id:
-    return the key and the id
-    :param concept_repr:
-    :return:
-    """
-    if not (concept_repr and isinstance(concept_repr, str) and concept_repr.startswith(":c:")):
-        return None, None
-
-    i = 3
-    length = len(concept_repr)
-    key = ""
-    while i < length:
-        if concept_repr[i] == ":":
-            break
-        key += concept_repr[i]
-        i += 1
-    else:
-        return None, None
-
-    i += 1
-    if i >= length:
-        return key, None
-
-    id = ""
-    while i < length:
-        if concept_repr[i] == ":":
-            break
-        id += concept_repr[i]
-        i += 1
-    else:
-        return None, None
-
-    return key, id
-
-
 def decode_enum(enum_repr: str):
     """
     Tries to transform ClassName.Name into an enum
@@ -300,3 +264,110 @@ def decode_enum(enum_repr: str):
 
     except TypeError:
         return None
+
+
+def str_concept(t):
+    """
+    The key,id identifiers of a concept are stored in a tuple
+    we want to return the key and the id, separated by a pipe
+    None value must be replaced by an empty string
+
+    >>> assert str_concept(("key", "id")) == "c:key|id:"
+    >>> assert str_concept((None, "id")) == "c:|id:"
+    >>> assert str_concept(("key", None)) == "c:key:"
+    >>> assert str_concept((None, None)) == ""
+    :param t:
+    :return:
+    """
+    if isinstance(t, tuple):
+        key, id_ = t[0], t[1]
+    else:
+        key, id_ = t.key, t.id
+
+    if key is None and id_ is None:
+        return ""
+
+    result = 'c:' if key is None else "c:" + key
+    if id_:
+        result += "|" + id_
+    return result + ":"
+
+
+def unstr_concept(concept_repr):
+    """
+    if concept_repr is like :c:key:id:
+    return the key and the id
+    :param concept_repr:
+    :return:
+    """
+    if not (concept_repr and isinstance(concept_repr, str) and concept_repr.startswith("c:")):
+        return None, None
+
+    i = 2
+    length = len(concept_repr)
+    key = ""
+    while i < length:
+        c = concept_repr[i]
+        if c in (":", "|"):
+            break
+        key += c
+        i += 1
+    else:
+        return None, None
+
+    if c == ":":
+        return key if key != "" else None, None
+
+    i += 1
+    id = ""
+    while i < length:
+        c = concept_repr[i]
+        if c == ":":
+            break
+        id += c
+        i += 1
+    else:
+        return None, None
+
+    return key if key != "" else None, id if id != "" else None
+
+
+def encode_concept(t, use_concept=False):
+    """
+    Given a tuple of concept id, concept id
+    Create a valid Python identifier that can be parsed back
+
+    >>> assert encode_concept(("key", "id")) == "__C__KEY_key__ID_id__C__"
+    >>> assert encode_concept((None, "id")) == "__C__KEY_00None00__ID_id__C__"
+    >>> assert encode_concept(("key", None)) == "__C__KEY_key__ID_00None00__C__"
+    >>> assert encode_concept(("key", "id"), True) == "__C__USE_CONCEPT__KEY_key__ID_id__C__"
+
+    :param t:
+    :param use_concept:
+    :return:
+    """
+
+    key, id_ = (t[0], t[1]) if isinstance(t, tuple) else (t.key, t.id)
+    prefix = "__C__USE_CONCEPT" if use_concept else "__C"
+    sanitized_key = "".join(c if c.isalnum() else "0" for c in key) if key else "00None00"
+    return prefix + f"__KEY_{sanitized_key}__ID_{id_ or '00None00'}__C__"
+
+
+decode_regex = re.compile(r"__KEY_(\w+)__ID_(\w+)__C__")
+
+
+def decode_concept(text):
+    """
+    Decode what was encoded by encode_concept_key_id
+    :param text:
+    :return:
+    """
+    use_concept = text.startswith("__C__USE_CONCEPT")
+    m = decode_regex.search(text)
+    lookup = {"00None00": None}
+    if m:
+        key = lookup.get(m.group(1), m.group(1))
+        id_ = lookup.get(m.group(2), m.group(2))
+        return key, id_, use_concept
+
+    return None, None, None