teaql 0.1.0__py3-none-any.whl

teaql/core/__init__.py

@@ -0,0 +1,63 @@
+from .value import Value, DataType, Timestamp
+from .entity import BaseEntityData
+from .expr import (
+    Expr, ExprBuilder, BinaryOp, ExprFunction,
+    ColumnExpr, ValueExpr, FunctionExpr, BinaryExpr,
+    SubQueryExpr, BetweenExpr, IsNullExpr, IsNotNullExpr,
+    AndExpr, OrExpr, NotExpr
+)
+from .query import (
+    SelectQuery, SortDirection, OrderBy, Aggregate, AggregateFunction,
+    Slice, RelationLoad, RawSqlProjection, ObjectGroupBy,
+    AggregationCacheOptions, StreamConfig, NamedExpr
+)
+from .mutation import (
+    InsertCommand, UpdateCommand, DeleteCommand, RecoverCommand,
+    BatchInsertCommand, BatchUpdateCommand, TraceNode,
+    InsertCommand, UpdateCommand, DeleteCommand, RecoverCommand,
+    BatchInsertCommand, BatchUpdateCommand, MutationRequest
+)
+from .graph import GraphNode
+
+from .meta import EntityDescriptor, PropertyDescriptor
+from .list import SmartList
+from .eval import LoadState, EvalResult
+from .safe_expression import SafeExpression
+from .xls import XlsWorkbook, XlsPage, XlsBlock, XlsBlockBuildContext
+
+__all__ = [
+    "Value", "DataType", "Timestamp",
+    "BaseEntityData",
+    "Expr", "ExprBuilder", "BinaryOp", "ExprFunction",
+    "SelectQuery", "SortDirection", "OrderBy", "Aggregate", "AggregateFunction",
+    "Slice", "RelationLoad", "RawSqlProjection", "ObjectGroupBy",
+    "AggregationCacheOptions", "StreamConfig", "NamedExpr",
+    "InsertCommand", "UpdateCommand", "DeleteCommand", "RecoverCommand",
+    "BatchInsertCommand", "BatchUpdateCommand", "TraceNode",
+    "InsertCommand", "UpdateCommand", "DeleteCommand", "RecoverCommand",
+    "BatchInsertCommand", "BatchUpdateCommand", "MutationRequest",
+    "GraphNode",
+    "EntityDescriptor", "PropertyDescriptor", "SmartList",
+    "LoadState", "EvalResult", "SafeExpression",
+    "XlsWorkbook", "XlsPage", "XlsBlock", "XlsBlockBuildContext"
+]
+import builtins
+builtins.uint64 = int
+builtins.int64 = int
+builtins.string = str
+builtins.time = type('time', (), {'Time': str})
+builtins.typing = __import__('typing')
+builtins.decimal = __import__('decimal')
+TypeU64 = "U64"
+TypeI64 = "I64"
+TypeText = "Text"
+TypeTimestamp = "Timestamp"
+TypeDecimal = "Decimal"
+TypeJson = "Json"
+TypeBool = "Bool"
+TypeDate = "Date"
+def NewInsertCommand(entity: str):
+    return InsertCommand(entity=entity)
+
+def NewUpdateCommand(entity: str, id_val):
+    return UpdateCommand(entity=entity, id=Value.from_any(id_val))

teaql/core/entity.py

@@ -0,0 +1,35 @@
+from typing import Dict, Optional, Any
+from .value import Value
+
+class BaseEntityData:
+    def __init__(self, id: int = 0, version: int = 0, dynamic: Optional[Dict[str, Value]] = None):
+        self.id = id
+        self.version = version
+        self.dynamic = dynamic or {}
+
+    @classmethod
+    def new(cls) -> 'BaseEntityData':
+        return cls()
+
+    def with_id(self, id: int) -> 'BaseEntityData':
+        self.id = id
+        return self
+
+    def with_version(self, version: int) -> 'BaseEntityData':
+        self.version = version
+        return self
+
+    def with_dynamic(self, key: str, value: Any) -> 'BaseEntityData':
+        self.dynamic[key] = Value.from_any(value)
+        return self
+
+    def to_record(self) -> Dict[str, Any]:
+        rec = {"id": self.id, "version": self.version}
+        if self.dynamic:
+            for k, v in self.dynamic.items():
+                rec[k] = v.to_json_value()
+        return rec
+    def get_dynamic(self, key: str) -> Optional[Value]:
+        return self.dynamic.get(key)
+    def put_dynamic(self, key, value):
+        self.dynamic[key] = value

teaql/core/eval.py

@@ -0,0 +1,84 @@
+from enum import Enum, auto
+from typing import Set, Any, Generic, TypeVar, Callable
+
+class LoadStateType(Enum):
+    NotLoaded = auto()
+    Partial = auto()
+    FullyLoaded = auto()
+
+class LoadState:
+    def __init__(self, state_type: LoadStateType = LoadStateType.NotLoaded, fields: Set[str] = None):
+        self.state_type = state_type
+        self.fields = fields or set()
+
+    @classmethod
+    def NotLoaded(cls) -> 'LoadState':
+        return cls(LoadStateType.NotLoaded)
+
+    @classmethod
+    def Partial(cls, fields: Set[str]) -> 'LoadState':
+        return cls(LoadStateType.Partial, fields)
+
+    @classmethod
+    def FullyLoaded(cls) -> 'LoadState':
+        return cls(LoadStateType.FullyLoaded)
+
+    def is_loaded(self, field_or_relation: str) -> bool:
+        if self.state_type == LoadStateType.NotLoaded:
+            return False
+        if self.state_type == LoadStateType.FullyLoaded:
+            return True
+        return field_or_relation in self.fields
+
+T = TypeVar('T')
+U = TypeVar('U')
+
+class EvalResultType(Enum):
+    Value = auto()
+    Null = auto()
+    NotLoaded = auto()
+
+class EvalResult(Generic[T]):
+    def __init__(self, result_type: EvalResultType, value: T = None, failed_node: str = None, attempted_path: str = None):
+        self.result_type = result_type
+        self.value = value
+        self.failed_node = failed_node
+        self.attempted_path = attempted_path
+
+    @classmethod
+    def Value(cls, value: T) -> 'EvalResult[T]':
+        return cls(EvalResultType.Value, value=value)
+
+    @classmethod
+    def Null(cls) -> 'EvalResult[T]':
+        return cls(EvalResultType.Null)
+
+    @classmethod
+    def NotLoaded(cls, failed_node: str, attempted_path: str) -> 'EvalResult[T]':
+        return cls(EvalResultType.NotLoaded, failed_node=failed_node, attempted_path=attempted_path)
+
+    def and_then(self, field_name: str, f: Callable[[T], 'EvalResult[U]']) -> 'EvalResult[U]':
+        if self.result_type == EvalResultType.Value:
+            res = f(self.value)
+            if res.result_type == EvalResultType.NotLoaded:
+                new_path = res.attempted_path
+                if new_path == field_name:
+                    pass
+                elif not new_path:
+                    new_path = field_name
+                else:
+                    new_path = f"{field_name}.{new_path}"
+                return EvalResult.NotLoaded(res.failed_node, new_path)
+            return res
+        elif self.result_type == EvalResultType.Null:
+            return EvalResult.Null()
+        else:
+            return EvalResult.NotLoaded(self.failed_node, self.attempted_path)
+
+    def map(self, f: Callable[[T], U]) -> 'EvalResult[U]':
+        if self.result_type == EvalResultType.Value:
+            return EvalResult.Value(f(self.value))
+        elif self.result_type == EvalResultType.Null:
+            return EvalResult.Null()
+        else:
+            return EvalResult.NotLoaded(self.failed_node, self.attempted_path)

teaql/core/expr.py

@@ -0,0 +1,345 @@
+from enum import Enum, auto
+from typing import List, Optional, Any, Union
+from dataclasses import dataclass
+from .value import Value
+
+class BinaryOp(Enum):
+    Eq = auto()
+    Ne = auto()
+    Gt = auto()
+    Gte = auto()
+    Lt = auto()
+    Lte = auto()
+    Like = auto()
+    NotLike = auto()
+    In = auto()
+    NotIn = auto()
+    InLarge = auto()
+    NotInLarge = auto()
+
+class ExprFunction(Enum):
+    Soundex = auto()
+    Gbk = auto()
+    Count = auto()
+    Sum = auto()
+    Avg = auto()
+    Min = auto()
+    Max = auto()
+    Stddev = auto()
+    StddevPop = auto()
+    VarSamp = auto()
+    VarPop = auto()
+    BitAnd = auto()
+    BitOr = auto()
+    BitXor = auto()
+
+class Expr:
+    @staticmethod
+    def eq(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.Eq, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+    @staticmethod
+    def ne(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.Ne, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+    @staticmethod
+    def gt(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.Gt, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+    @staticmethod
+    def gte(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.Gte, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+    @staticmethod
+    def lt(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.Lt, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+    @staticmethod
+    def lte(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.Lte, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+    @staticmethod
+    def like(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.Like, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+    @staticmethod
+    def not_like(field: str, value: Any) -> 'Expr':
+        return BinaryExpr(ExprBuilder.column(field), BinaryOp.NotLike, ExprBuilder.value(value) if not isinstance(value, Expr) else value)
+
+    @staticmethod
+    def new_and(left: 'Expr', right: 'Expr') -> 'Expr':
+        return AndExpr([left, right])
+
+    @staticmethod
+    def new_or(left: 'Expr', right: 'Expr') -> 'Expr':
+        return OrExpr([left, right])
+
+
+@dataclass
+class ColumnExpr(Expr):
+    name: str
+
+@dataclass
+class ValueExpr(Expr):
+    value: Value
+
+@dataclass
+class FunctionExpr(Expr):
+    function: ExprFunction
+    args: List[Expr]
+
+@dataclass
+class BinaryExpr(Expr):
+    left: Expr
+    op: BinaryOp
+    right: Expr
+
+@dataclass
+class SubQueryExpr(Expr):
+    left: Expr
+    op: BinaryOp
+    entity: Any  # EntityDescriptor
+    query: Any   # SelectQuery
+
+@dataclass
+class BetweenExpr(Expr):
+    expr: Expr
+    lower: Expr
+    upper: Expr
+
+@dataclass
+class IsNullExpr(Expr):
+    expr: Expr
+
+@dataclass
+class IsNotNullExpr(Expr):
+    expr: Expr
+
+@dataclass
+class AndExpr(Expr):
+    exprs: List[Expr]
+
+@dataclass
+class OrExpr(Expr):
+    exprs: List[Expr]
+
+@dataclass
+class NotExpr(Expr):
+    expr: Expr
+
+class ExprBuilder:
+    @staticmethod
+    def column(name: str) -> Expr:
+        return ColumnExpr(name)
+
+    @staticmethod
+    def value(value: Any) -> Expr:
+        return ValueExpr(Value.from_any(value))
+
+    @staticmethod
+    def function(function: ExprFunction, args: List[Expr]) -> Expr:
+        return FunctionExpr(function, args)
+
+    @staticmethod
+    def soundex(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Soundex, [expr])
+
+    @staticmethod
+    def gbk(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Gbk, [expr])
+
+    @staticmethod
+    def count_all() -> Expr:
+        return ExprBuilder.function(ExprFunction.Count, [])
+
+    @staticmethod
+    def count_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Count, [expr])
+
+    @staticmethod
+    def sum_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Sum, [expr])
+
+    @staticmethod
+    def avg_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Avg, [expr])
+
+    @staticmethod
+    def min_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Min, [expr])
+
+    @staticmethod
+    def max_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Max, [expr])
+
+    @staticmethod
+    def stddev_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.Stddev, [expr])
+
+    @staticmethod
+    def stddev_pop_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.StddevPop, [expr])
+
+    @staticmethod
+    def var_samp_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.VarSamp, [expr])
+
+    @staticmethod
+    def var_pop_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.VarPop, [expr])
+
+    @staticmethod
+    def bit_and_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.BitAnd, [expr])
+
+    @staticmethod
+    def bit_or_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.BitOr, [expr])
+
+    @staticmethod
+    def bit_xor_expr(expr: Expr) -> Expr:
+        return ExprBuilder.function(ExprFunction.BitXor, [expr])
+
+
+def column(name: str) -> Expr:
+    return ExprBuilder.column(name)
+
+def value(val: Any) -> Expr:
+    return ExprBuilder.value(val)
+
+def function(func: ExprFunction, args: List[Expr]) -> Expr:
+    return ExprBuilder.function(func, args)
+
+def soundex(expr: Expr) -> Expr:
+    return ExprBuilder.soundex(expr)
+
+def gbk(expr: Expr) -> Expr:
+    return ExprBuilder.gbk(expr)
+
+def count_all() -> Expr:
+    return ExprBuilder.count_all()
+
+def count_expr(expr: Expr) -> Expr:
+    return ExprBuilder.count_expr(expr)
+
+def sum_expr(expr: Expr) -> Expr:
+    return ExprBuilder.sum_expr(expr)
+
+def avg_expr(expr: Expr) -> Expr:
+    return ExprBuilder.avg_expr(expr)
+
+def min_expr(expr: Expr) -> Expr:
+    return ExprBuilder.min_expr(expr)
+
+def max_expr(expr: Expr) -> Expr:
+    return ExprBuilder.max_expr(expr)
+
+def stddev_expr(expr: Expr) -> Expr:
+    return ExprBuilder.stddev_expr(expr)
+
+def stddev_pop_expr(expr: Expr) -> Expr:
+    return ExprBuilder.stddev_pop_expr(expr)
+
+def var_samp_expr(expr: Expr) -> Expr:
+    return ExprBuilder.var_samp_expr(expr)
+
+def var_pop_expr(expr: Expr) -> Expr:
+    return ExprBuilder.var_pop_expr(expr)
+
+def bit_and_expr(expr: Expr) -> Expr:
+    return ExprBuilder.bit_and_expr(expr)
+
+def bit_or_expr(expr: Expr) -> Expr:
+    return ExprBuilder.bit_or_expr(expr)
+
+def bit_xor_expr(expr: Expr) -> Expr:
+    return ExprBuilder.bit_xor_expr(expr)
+
+def binary(left: Expr, op: BinaryOp, right: Expr) -> Expr:
+    return BinaryExpr(left, op, right)
+
+def eq(field: str, val: Any) -> Expr:
+    return Expr.eq(field, val)
+
+def ne(field: str, val: Any) -> Expr:
+    return Expr.ne(field, val)
+
+def gt(field: str, val: Any) -> Expr:
+    return Expr.gt(field, val)
+
+def gte(field: str, val: Any) -> Expr:
+    return Expr.gte(field, val)
+
+def lt(field: str, val: Any) -> Expr:
+    return Expr.lt(field, val)
+
+def lte(field: str, val: Any) -> Expr:
+    return Expr.lte(field, val)
+
+def like(field: str, val: Any) -> Expr:
+    return Expr.like(field, val)
+
+def not_like(field: str, val: Any) -> Expr:
+    return Expr.not_like(field, val)
+
+def contain(field: str, val: Any) -> Expr:
+    return Expr.like(field, f"%{val}%")
+
+def not_contain(field: str, val: Any) -> Expr:
+    return Expr.not_like(field, f"%{val}%")
+
+def begin_with(field: str, val: Any) -> Expr:
+    return Expr.like(field, f"{val}%")
+
+def not_begin_with(field: str, val: Any) -> Expr:
+    return Expr.not_like(field, f"{val}%")
+
+def end_with(field: str, val: Any) -> Expr:
+    return Expr.like(field, f"%{val}")
+
+def not_end_with(field: str, val: Any) -> Expr:
+    return Expr.not_like(field, f"%{val}")
+
+def sound_like(field: str, val: Any) -> Expr:
+    return eq(soundex(column(field)), soundex(value(val)))
+
+def in_list(field: str, vals: List[Any]) -> Expr:
+    return BinaryExpr(column(field), BinaryOp.In, value(vals))
+
+def not_in_list(field: str, vals: List[Any]) -> Expr:
+    return BinaryExpr(column(field), BinaryOp.NotIn, value(vals))
+
+def in_large(field: str, vals: List[Any]) -> Expr:
+    return BinaryExpr(column(field), BinaryOp.InLarge, value(vals))
+
+def not_in_large(field: str, vals: List[Any]) -> Expr:
+    return BinaryExpr(column(field), BinaryOp.NotInLarge, value(vals))
+
+def is_null(expr: Expr) -> Expr:
+    return IsNullExpr(expr)
+
+def is_not_null(expr: Expr) -> Expr:
+    return IsNotNullExpr(expr)
+
+def between(expr: Expr, lower: Expr, upper: Expr) -> Expr:
+    return BetweenExpr(expr, lower, upper)
+
+def compare_columns(left: str, op: BinaryOp, right: str) -> Expr:
+    return BinaryExpr(column(left), op, column(right))
+
+def subquery(left: Expr, op: BinaryOp, entity: Any, query: Any) -> Expr:
+    return SubQueryExpr(left, op, entity, query)
+
+def in_subquery(left: Expr, entity: Any, query: Any) -> Expr:
+    return subquery(left, BinaryOp.In, entity, query)
+
+def not_in_subquery(left: Expr, entity: Any, query: Any) -> Expr:
+    return subquery(left, BinaryOp.NotIn, entity, query)
+
+def negate(expr: Expr) -> Expr:
+    return NotExpr(expr)
+
+def and_expr(left: Expr, right: Expr) -> Expr:
+    return Expr.new_and(left, right)
+
+def or_expr(left: Expr, right: Expr) -> Expr:
+    return OrExpr([left, right])
+
+def and_(*exprs: Expr) -> Expr:
+    return AndExpr(list(exprs))
+
+def or_(*exprs: Expr) -> Expr:
+    return OrExpr(list(exprs))

teaql/core/graph.py

@@ -0,0 +1,94 @@
+from typing import Any, Dict, List, Optional
+from enum import Enum
+
+class EntityGraphOperation(Enum):
+    SAVE = 1
+    DELETE = 2
+
+class GraphNode:
+    def __init__(self, entity: str):
+        self.entity = entity
+        self.fields: Dict[str, Any] = {}
+        self.is_deleted: bool = False
+        self.comment_text: Optional[str] = None
+        self.children: Dict[str, List['GraphNode']] = {}
+
+    def child(self, rel: str) -> 'GraphNode':
+        if rel not in self.children:
+            self.children[rel] = []
+        node = GraphNode(rel)
+        self.children[rel].append(node)
+        return node
+
+    def relation(self, rel: str) -> 'GraphNode':
+        return self.child(rel)
+
+    def relations(self) -> Dict[str, List['GraphNode']]:
+        return self.children
+
+    def remove(self, rel: str):
+        if rel in self.children:
+            del self.children[rel]
+
+    def set(self, field: str, val: Any) -> 'GraphNode':
+        self.fields[field] = val
+        return self
+
+    def value(self, field: str) -> Optional[Any]:
+        return self.fields.get(field)
+
+    def delete(self) -> 'GraphNode':
+        self.is_deleted = True
+        return self
+
+    def comment(self, text: str) -> 'GraphNode':
+        self.comment_text = text
+        return self
+
+    def set_comment(self, text: str):
+        self.comment_text = text
+
+    def id(self) -> Optional[Any]:
+        return self.fields.get('id')
+
+    def operation(self) -> Optional['EntityGraphOperation']:
+        if self.is_deleted:
+            return EntityGraphOperation.DELETE
+        return EntityGraphOperation.SAVE
+
+    def reference(self, rel: str, ref_id: Any) -> 'GraphNode':
+        node = self.child(rel)
+        node.set('id', ref_id)
+        return node
+
+class EntityGraphBuilder:
+    def __init__(self, entity: str):
+        self.node = GraphNode(entity)
+
+    def set(self, key: str, value: Any) -> 'EntityGraphBuilder':
+        self.node.set(key, value)
+        return self
+
+    def delete(self) -> 'EntityGraphBuilder':
+        self.node.delete()
+        return self
+
+    def comment(self, text: str) -> 'EntityGraphBuilder':
+        self.node.comment(text)
+        return self
+
+    def child(self, child_node: GraphNode) -> 'EntityGraphBuilder':
+        self.node.children.append(child_node)
+        return self
+
+    def save(self) -> 'EntityGraphBuilder':
+        self.node.operation = EntityGraphOperation.SAVE
+        return self
+
+    def build(self) -> GraphNode:
+        return self.node
+
+class EntityGraph:
+    @staticmethod
+    def new(entity: str) -> EntityGraphBuilder:
+        return EntityGraphBuilder(entity)

teaql/core/list.py

@@ -0,0 +1,80 @@
+from typing import Any, List, Dict, Iterator
+
+class SmartList:
+    def __init__(self, data: List[Any], facets: Dict[str, Any] = None, total_count: int = None):
+        self.data = data
+        self.facets = facets or {}
+        self.total_count = total_count if total_count is not None else len(data)
+
+    def facet(self, name: str) -> Any:
+        return self.facets.get(name)
+
+    def __iter__(self) -> Iterator[Any]:
+        return iter(self.data)
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def map(self, f) -> 'SmartList':
+        return SmartList([f(x) for x in self.data], self.facets, self.total_count)
+
+    def filter(self, f) -> 'SmartList':
+        return SmartList([x for x in self.data if f(x)], self.facets, self.total_count)
+
+    def flat_map(self, f) -> 'SmartList':
+        result = []
+        for x in self.data:
+            result.extend(f(x))
+        return SmartList(result, self.facets, self.total_count)
+
+    def first(self) -> Any:
+        return self.data[0] if self.data else None
+
+    def last(self) -> Any:
+        return self.data[-1] if self.data else None
+
+    def is_empty(self) -> bool:
+        return len(self.data) == 0
+
+    def into_vec(self) -> List[Any]:
+        return self.data
+
+    def get(self, index: int) -> Any:
+        if 0 <= index < len(self.data):
+            return self.data[index]
+        return None
+
+    def retain(self, f):
+        self.data = [x for x in self.data if f(x)]
+
+def to_list(lst: SmartList) -> List[Any]:
+    return lst.data
+
+def to_set(lst: SmartList) -> set:
+    return set(lst.data)
+
+def identity_map(lst: SmartList) -> Dict[Any, Any]:
+    return {x: x for x in lst.data}
+
+def group_by(lst: SmartList, key_func) -> Dict[Any, List[Any]]:
+    result = {}
+    for item in lst.data:
+        key = key_func(item)
+        if key not in result:
+            result[key] = []
+        result[key].append(item)
+    return result
+
+def into_records(lst: SmartList) -> List[Dict[str, Any]]:
+    # Assuming the elements are entities with a .values dict or similar, or they are just dicts
+    return [x.values if hasattr(x, 'values') else dict(x) for x in lst.data]
+
+def ids(lst: SmartList) -> List[Any]:
+    # Assuming elements have a .get('id') or similar
+    return [x.get('id') if isinstance(x, dict) else getattr(x, 'id', None) for x in lst.data]
+
+def map_by_id(lst: SmartList) -> Dict[Any, Any]:
+    return { (x.get('id') if isinstance(x, dict) else getattr(x, 'id', None)): x for x in lst.data }
+
+def versions(lst: SmartList) -> List[Any]:
+    return [x.get('version') if isinstance(x, dict) else getattr(x, 'version', None) for x in lst.data]