pydpm_xl 0.1.10__py3-none-any.whl

py_dpm/utils/ast_serialization.py

@@ -0,0 +1,481 @@
+#!/usr/bin/env python3
+"""
+AST to JSON serialization utilities for pyDPM
+"""
+
+from py_dpm.AST.ASTVisitor import NodeVisitor
+
+
+class ASTToJSONVisitor(NodeVisitor):
+    """Visitor that converts AST nodes to JSON using the existing visitor pattern infrastructure."""
+
+    def __init__(self, with_context=None):
+        self.with_context = with_context
+
+    def visit(self, node):
+        """Override the base visit to handle None values."""
+        if node is None:
+            return None
+        return super().visit(node)
+
+    def visit_BinOp(self, node):
+        """Visit BinOp nodes."""
+        # Handle match operations as MatchCharactersOp
+        if node.op == 'match':
+            return {
+                'class_name': 'MatchCharactersOp',
+                'operand': self.visit(node.left),
+                'pattern': self.visit(node.right)
+            }
+
+        return {
+            'class_name': 'BinOp',
+            'op': node.op,
+            'left': self.visit(node.left),
+            'right': self.visit(node.right)
+        }
+
+    def visit_UnaryOp(self, node):
+        """Visit UnaryOp nodes."""
+        return {
+            'class_name': 'UnaryOp',
+            'op': node.op,
+            'operand': self.visit(node.operand)
+        }
+
+    def visit_VarID(self, node):
+        """Visit VarID nodes with context handling."""
+        result = {
+            'class_name': 'VarID'
+        }
+
+        # Helper function to check if a value represents multiple items, ranges, or wildcards
+        def is_multi_range_or_wildcard(values):
+            if not isinstance(values, list):
+                return False
+            if len(values) != 1:
+                return len(values) > 1  # Multiple values
+            # Check if single value contains range syntax or wildcards
+            single_val = values[0]
+            if isinstance(single_val, str):
+                return '-' in single_val or single_val == '*'
+            return False
+
+        # Apply context first, then override with node-specific values
+        if self.with_context:
+            # Handle simple context fields
+            for context_attr in ['table', 'interval', 'default']:
+                if hasattr(self.with_context, context_attr):
+                    context_value = getattr(self.with_context, context_attr)
+                    # Special handling for interval field
+                    if context_attr == 'interval':
+                        if context_value is not None:
+                            # Context has explicit interval value, use it
+                            result[context_attr] = context_value
+                        else:
+                            # Context interval is None, will be handled by node processing
+                            pass
+                    elif context_value is not None:
+                        # Handle AST objects in context (like Constant)
+                        if hasattr(context_value, 'toJSON'):
+                            if context_value.__class__.__name__ == 'Constant':
+                                context_json = context_value.toJSON()
+                                result[context_attr] = context_json.get('value', context_value)
+                            else:
+                                result[context_attr] = self.visit(context_value)
+                        else:
+                            result[context_attr] = context_value
+
+            # Handle array context fields (rows, cols, sheets) - only convert to scalar if single value and not range
+            array_mappings = {'rows': 'row', 'cols': 'column', 'sheets': 'sheet'}
+            for context_attr, result_key in array_mappings.items():
+                if hasattr(self.with_context, context_attr):
+                    context_value = getattr(self.with_context, context_attr)
+                    if context_value is not None:
+                        # Only create scalar field if it's a single non-range, non-wildcard value
+                        if isinstance(context_value, list) and len(context_value) == 1 and not is_multi_range_or_wildcard(context_value):
+                            result[result_key] = context_value[0]
+                        # For multi-value, range, or wildcard contexts, don't create scalar fields
+                        # The expected JSON has data field instead (handled by database layer)
+
+        # Override with node-specific values using same logic
+        node_array_mappings = {'rows': 'row', 'cols': 'column', 'sheets': 'sheet'}
+
+        # Handle simple node fields
+        for node_attr in ['table', 'interval', 'default']:
+            if hasattr(node, node_attr):
+                node_value = getattr(node, node_attr)
+                # Special handling for interval field
+                if node_attr == 'interval':
+                    if node_value is not None:
+                        # Node has explicit interval value, use it
+                        result[node_attr] = node_value
+                    elif node_attr not in result:
+                        # No context value and node value is None, default to False
+                        result[node_attr] = False
+                    # If context already set this field, don't override
+                elif node_value is not None:
+                    # Handle AST objects (like Constant)
+                    if hasattr(node_value, 'toJSON'):
+                        if node_value.__class__.__name__ == 'Constant':
+                            node_json = node_value.toJSON()
+                            result[node_attr] = node_json.get('value', node_value)
+                        else:
+                            result[node_attr] = self.visit(node_value)
+                    else:
+                        result[node_attr] = node_value
+
+        # Handle array node fields
+        for node_attr, result_key in node_array_mappings.items():
+            if hasattr(node, node_attr):
+                node_value = getattr(node, node_attr)
+                if node_value is not None:
+                    # Only create scalar field if it's a single non-range, non-wildcard value
+                    if isinstance(node_value, list) and len(node_value) == 1 and not is_multi_range_or_wildcard(node_value):
+                        result[result_key] = node_value[0]
+
+        # Handle data field if present (contains datapoint and operand_reference_id)
+        if hasattr(node, 'data') and node.data is not None:
+            # Convert pandas DataFrame to list of dictionaries
+            if hasattr(node.data, 'to_dict'):
+                data_records = node.data.to_dict('records')
+                # Transform the data to match expected JSON structure
+                transformed_data = []
+                for record in data_records:
+                    # Map database columns to expected JSON fields
+                    transformed_record = {}
+                    if 'variable_id' in record:
+                        transformed_record['datapoint'] = record['variable_id']
+                    if 'cell_id' in record:
+                        transformed_record['operand_reference_id'] = record['cell_id']
+                    # Include additional fields if they exist
+                    for field in ['cell_code', 'table_code', 'row_code', 'column_code', 'sheet_code', 'data_type', 'table_vid']:
+                        if field in record:
+                            transformed_record[field] = record[field]
+                    transformed_data.append(transformed_record)
+                result['data'] = transformed_data
+            else:
+                # Handle other data formats if needed
+                result['data'] = node.data
+
+        # Filter out None values and internal fields
+        filtered_result = {k: v for k, v in result.items() if v is not None}
+        return filtered_result
+
+    def visit_AggregationOp(self, node):
+        """Visit AggregationOp nodes."""
+        return {
+            'class_name': 'AggregationOp',
+            'op': node.op,
+            'operand': self.visit(node.operand)
+        }
+
+    def visit_Constant(self, node):
+        """Visit Constant nodes."""
+        return {
+            'class_name': 'Constant',
+            'type_': getattr(node, 'type_', getattr(node, 'type', None)),
+            'value': node.value
+        }
+
+    def visit_ParExpr(self, node):
+        """Visit ParExpr nodes."""
+        return {
+            'class_name': 'ParExpr',
+            'expression': self.visit(node.expression)
+        }
+
+    def visit_ConditionalOp(self, node):
+        """Visit ConditionalOp nodes."""
+        result = {
+            'class_name': 'ConditionalOp',
+            'condition': self.visit(node.condition),
+            'then_expr': self.visit(node.then_expr)
+        }
+
+        if hasattr(node, 'else_expr') and node.else_expr is not None:
+            result['else_expr'] = self.visit(node.else_expr)
+
+        return result
+
+    def visit_Function(self, node):
+        """Visit Function nodes."""
+        result = {
+            'class_name': 'Function',
+            'name': node.name
+        }
+
+        if hasattr(node, 'args') and node.args:
+            result['args'] = [self.visit(arg) for arg in node.args]
+
+        return result
+
+    def visit_Scalar(self, node):
+        """Visit Scalar nodes with item name normalization."""
+        result = {
+            'class_name': 'Scalar'
+        }
+
+        # Apply item name normalization for version compatibility
+        if hasattr(node, 'item') and node.item:
+            item_name = node.item
+            # Handle version differences in scalar naming
+            # e.g., eba_qEC -> eba_EC, eba_qLR -> eba_LR
+            if isinstance(item_name, str) and item_name.startswith('eba_q'):
+                normalized_item = item_name.replace('eba_q', 'eba_')
+                result['item'] = normalized_item
+            else:
+                result['item'] = item_name
+
+        if hasattr(node, 'member') and node.member:
+            result['member'] = node.member
+
+        return result
+
+    def generic_visit(self, node):
+        """Generic visit method for nodes without specific visitors."""
+        result = {
+            'class_name': node.__class__.__name__
+        }
+
+        # Try to get common attributes
+        for attr in ['op', 'name', 'value', 'type_', 'item', 'member']:
+            if hasattr(node, attr):
+                attr_value = getattr(node, attr)
+                if attr_value is not None:
+                    result[attr] = attr_value
+
+        # Handle child nodes
+        for attr in ['left', 'right', 'operand', 'expression', 'condition', 'then_expr', 'else_expr']:
+            if hasattr(node, attr):
+                attr_value = getattr(node, attr)
+                if attr_value is not None:
+                    result[attr] = self.visit(attr_value)
+
+        # Handle lists of child nodes
+        for attr in ['children', 'args']:
+            if hasattr(node, attr):
+                attr_value = getattr(node, attr)
+                if attr_value and isinstance(attr_value, list):
+                    result[attr] = [self.visit(child) for child in attr_value]
+
+        return result
+
+
+# Original serialization functions (kept for backward compatibility)
+import json
+from py_dpm.AST import ASTObjects
+
+
+def expand_with_expression(node):
+    """
+    Recursively expand WithExpression nodes by merging partial selections into cell references.
+
+    Args:
+        node: AST node to process
+
+    Returns:
+        Expanded AST node
+    """
+    if node is None:
+        return None
+
+    if isinstance(node, list):
+        return [expand_with_expression(item) for item in node]
+
+    if isinstance(node, dict):
+        return {key: expand_with_expression(value) for key, value in node.items()}
+
+    # Handle WithExpression expansion
+    if isinstance(node, ASTObjects.WithExpression):
+        partial_selection = node.partial_selection
+        expression = expand_with_expression(node.expression)
+
+        # Apply partial selection to all VarID nodes in the expression
+        return apply_partial_selection(expression, partial_selection)
+
+    # Handle Start node - check if it contains WithExpression
+    if isinstance(node, ASTObjects.Start):
+        expanded_children = []
+        for child in node.children:
+            if isinstance(child, ASTObjects.WithExpression):
+                # Expand the WithExpression and return just the expanded expression
+                expanded = expand_with_expression(child)
+                expanded_children.append(expanded)
+            else:
+                expanded_children.append(expand_with_expression(child))
+
+        # If we have a single expanded child that came from a WithExpression,
+        # return the expanded expression directly (no Start wrapper)
+        if len(expanded_children) == 1:
+            return expanded_children[0]
+        else:
+            return ASTObjects.Start(children=expanded_children)
+
+    # For other node types, recursively expand children
+    if hasattr(node, '__dict__'):
+        expanded_node = type(node).__new__(type(node))
+        for attr_name, attr_value in node.__dict__.items():
+            setattr(expanded_node, attr_name, expand_with_expression(attr_value))
+        return expanded_node
+
+    return node
+
+
+def apply_partial_selection(expression, partial_selection):
+    """
+    Apply partial selection to VarID nodes in the expression.
+
+    Args:
+        expression: Expression AST node
+        partial_selection: Partial selection VarID node
+
+    Returns:
+        Modified expression with partial selection applied
+    """
+    if expression is None:
+        return None
+
+    if isinstance(expression, list):
+        return [apply_partial_selection(item, partial_selection) for item in expression]
+
+    if isinstance(expression, dict):
+        return {key: apply_partial_selection(value, partial_selection) for key, value in expression.items()}
+
+    # Apply partial selection to VarID nodes
+    if isinstance(expression, ASTObjects.VarID):
+        # Create a new VarID with merged properties
+        new_varid = ASTObjects.VarID(
+            table=partial_selection.table if expression.table is None else expression.table,
+            rows=partial_selection.rows if expression.rows is None else expression.rows,
+            cols=expression.cols,  # Keep the original cols from the expression
+            sheets=partial_selection.sheets if expression.sheets is None else expression.sheets,
+            interval=partial_selection.interval if expression.interval is None else expression.interval,
+            default=partial_selection.default if expression.default is None else expression.default,
+            is_table_group=partial_selection.is_table_group if hasattr(partial_selection, 'is_table_group') else False
+        )
+        return new_varid
+
+    # For other node types, recursively apply to children
+    if hasattr(expression, '__dict__'):
+        modified_expr = type(expression).__new__(type(expression))
+        for attr_name, attr_value in expression.__dict__.items():
+            setattr(modified_expr, attr_name, apply_partial_selection(attr_value, partial_selection))
+        return modified_expr
+
+    return expression
+
+
+def serialize_ast(ast_obj):
+    """
+    Serialize an AST object to a JSON-serializable dictionary.
+    Expands WithExpression nodes before serialization.
+
+    Args:
+        ast_obj: An AST object instance
+
+    Returns:
+        dict: JSON-serializable dictionary representation
+    """
+    if ast_obj is None:
+        return None
+
+    # First expand any WithExpression nodes
+    expanded_obj = expand_with_expression(ast_obj)
+
+    if isinstance(expanded_obj, list):
+        return [serialize_ast(item) for item in expanded_obj]
+
+    if isinstance(expanded_obj, dict):
+        return {key: serialize_ast(value) for key, value in expanded_obj.items()}
+
+    if hasattr(expanded_obj, 'toJSON'):
+        serialized = expanded_obj.toJSON()
+        # Recursively serialize nested AST objects
+        for key, value in serialized.items():
+            if key != 'class_name':
+                serialized[key] = serialize_ast(value)
+        return serialized
+
+    # For basic types (str, int, float, bool)
+    if isinstance(expanded_obj, (str, int, float, bool, type(None))):
+        return expanded_obj
+
+    # Fallback: serialize as dict for objects without toJSON
+    return expanded_obj.__dict__
+
+
+def deserialize_ast(data):
+    """
+    Deserialize a JSON dictionary back to an AST object.
+
+    Args:
+        data: Dictionary or list from JSON
+
+    Returns:
+        AST object instance
+    """
+    if data is None:
+        return None
+
+    if isinstance(data, list):
+        return [deserialize_ast(item) for item in data]
+
+    if isinstance(data, dict):
+        if 'class_name' in data:
+            # This is an AST object
+            class_name = data['class_name']
+
+            # Get the class from ASTObjects module
+            if hasattr(ASTObjects, class_name):
+                cls = getattr(ASTObjects, class_name)
+
+                # Create a new instance
+                obj = object.__new__(cls)
+
+                # Initialize the base AST attributes
+                obj.num = None
+                obj.prev = None
+
+                # Set all the attributes from the serialized data
+                for key, value in data.items():
+                    if key != 'class_name':
+                        setattr(obj, key, deserialize_ast(value))
+
+                return obj
+            else:
+                raise ValueError(f"Unknown AST class: {class_name}")
+        else:
+            # Regular dictionary, deserialize values
+            return {key: deserialize_ast(value) for key, value in data.items()}
+
+    # For basic types
+    return data
+
+
+def ast_to_json_string(ast_obj, indent=None):
+    """
+    Convert AST object to JSON string.
+
+    Args:
+        ast_obj: AST object to serialize
+        indent: JSON indentation (optional)
+
+    Returns:
+        str: JSON string representation
+    """
+    return json.dumps(serialize_ast(ast_obj), indent=indent)
+
+
+def ast_from_json_string(json_str):
+    """
+    Create AST object from JSON string.
+
+    Args:
+        json_str: JSON string representation
+
+    Returns:
+        AST object instance
+    """
+    data = json.loads(json_str)
+    return deserialize_ast(data)

py_dpm/views/data_types.sql

@@ -0,0 +1,12 @@
+CREATE
+OR ALTER
+VIEW data_types AS
+SELECT vv.VariableID     as datapoint,
+       dt.Code           as data_type,
+       vv.StartReleaseID as start_release,
+       vv.EndReleaseID   as end_release
+from VariableVersion vv
+         inner join Property p on
+    p.PropertyID = vv.PropertyID
+         inner join DataType dt on
+    dt.DataTypeID = p.DataTypeID

py_dpm/views/datapoints.sql

@@ -0,0 +1,65 @@
+CREATE OR ALTER VIEW datapoints AS
+SELECT distinct tvc.CellCode AS cell_code,
+       tv.Code                                       AS table_code,
+       hvr.Code                                      AS row_code,
+       hvc.Code                                      AS column_code,
+       hvs.Code                                      AS sheet_code,
+       vv.VariableID                                 AS variable_id,
+       dt.Code                                       AS data_type,
+       tv.TableVID                                   AS table_vid,
+
+       p.PropertyID                                  AS property_id,
+       mv.StartReleaseID                             AS start_release,
+       mv.EndReleaseID                               AS end_release,
+       tvc.CellID                                    AS cell_id,
+       vv.ContextID                                  AS context_id,
+       vv.VariableVID                                AS variable_vid
+
+FROM dbo.TableVersionCell AS tvc
+
+         INNER JOIN dbo.TableVersion AS tv
+                    ON tvc.TableVID = tv.TableVID AND tvc.IsVoid = 0
+        INNER JOIN dbo.ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
+        inner join dbo.ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID
+
+         LEFT OUTER JOIN dbo.VariableVersion AS vv
+                    ON tvc.VariableVID = vv.VariableVID
+
+         LEFT OUTER JOIN dbo.Property AS p ON vv.PropertyID = p.PropertyID
+
+         LEFT OUTER JOIN dbo.DataType AS dt ON p.DataTypeID = dt.DataTypeID
+
+         INNER JOIN dbo.Cell AS c ON tvc.CellID = c.CellID
+
+         LEFT OUTER JOIN
+
+     (SELECT hv.HeaderVID, hv.HeaderID, hv.Code, hv.EndReleaseID, tvh.TableVID
+
+      FROM HeaderVersion hv
+
+               INNER JOIN TableVersionHeader tvh
+                          ON tvh.HeaderVID = hv.HeaderVID) hvr
+     ON hvr.HeaderID = c.RowID AND hvr.EndReleaseID IS NULL AND
+        tv.TableVID = hvr.TableVID
+
+         LEFT OUTER JOIN
+
+     (SELECT hv.HeaderVID, hv.HeaderID, hv.Code, hv.EndReleaseID, tvh.TableVID
+
+      FROM HeaderVersion hv
+
+               INNER JOIN TableVersionHeader tvh
+                          ON tvh.HeaderVID = hv.HeaderVID) hvc
+     ON hvc.HeaderID = c.ColumnID AND hvc.EndReleaseID IS NULL AND
+        tv.TableVID = hvc.TableVID
+
+         LEFT OUTER JOIN
+
+     (SELECT hv.HeaderVID, hv.HeaderID, hv.Code, hv.EndReleaseID, tvh.TableVID
+
+      FROM HeaderVersion hv
+
+               INNER JOIN TableVersionHeader tvh
+                          ON tvh.HeaderVID = hv.HeaderVID) hvs
+     ON hvs.HeaderID = c.SheetID AND hvs.EndReleaseID IS NULL AND
+        tv.TableVID = hvs.TableVID

py_dpm/views/hierarchy_operand_reference.sql

@@ -0,0 +1,11 @@
+CREATE OR ALTER VIEW hierarchy_operand_reference_info AS
+select distinct o.code         as operation_code,
+                on2.NodeID     as operation_node_id,
+                orl.CellID     as cell_id,
+                or2.VariableID as variable_id
+FROM OperandReferenceLocation orl
+         inner join OperandReference or2 on orl.OperandReferenceID = or2.OperandReferenceID
+         inner join OperationNode on2 on on2.NodeID = or2.NodeID
+         inner join OperationVersion ov on ov.OperationVID = on2.OperationVID
+         inner join Operation o on o.OperationID = ov.OperationID
+WHERE o.[Source] = 'hierarchy';

py_dpm/views/hierarchy_preconditions.sql

@@ -0,0 +1,13 @@
+CREATE OR ALTER VIEW hierarchy_preconditions
+AS
+SELECT ov.Expression as expression,
+       o.Code        as operation_code,
+       VV.Code       as variable_code
+FROM Operation o
+         inner join OperationVersion ov on o.OperationID = ov.OperationID
+         inner join dbo.OperationNode N on ov.OperationVID = N.OperationVID
+         inner join dbo.OperandReference OR2 on N.NodeID = OR2.NodeID
+         inner join dbo.Variable V on OR2.VariableID = V.VariableID
+         inner join dbo.VariableVersion VV on V.VariableID = VV.VariableID
+where o.Code like 'p_%'
+  and Expression not like '%or%';

py_dpm/views/hierarchy_variables.sql

@@ -0,0 +1,26 @@
+CREATE OR ALTER VIEW hierarchy_variables AS
+SELECT scv.SubCategoryID as subcategory_id,
+       vv.VariableVID    as variable_vid,
+       tvc.CellCode      as cell_code,
+       mp.Code           as main_property_code,
+       cp.Code           as context_property_code,
+       i.Code            as item_code,
+       mv.StartReleaseID as start_release_id,
+       mv.EndReleaseID   as end_release_id
+FROM SubCategoryVersion scv
+         inner join SubCategoryItem sci
+                    on sci.SubCategoryVID = scv.SubCategoryVID
+         inner join ContextComposition cc on cc.ItemID = sci.ItemID
+         inner join VariableVersion vv on vv.ContextID = cc.ContextID
+         inner join TableVersionCell tvc on vv.VariableVID = tvc.VariableVID
+         inner join Property p on vv.PropertyID = p.PropertyID
+         inner join DataType dt on p.DataTypeID = dt.DataTypeID
+         left join ItemCategory mp on mp.ItemID = vv.PropertyID and mp.EndReleaseID is Null
+         left join ItemCategory cp on cp.ItemID = cc.PropertyID and cp.EndReleaseID is Null
+         left join ItemCategory i on i.ItemID = cc.ItemID and i.EndReleaseID is Null
+         inner join TableVersion tv on tv.TableVID = tvc.TableVID
+         inner join ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
+         inner join ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID
+
+where dt.Code in ('m', 'i', 'r')
+  and tvc.CellCode is not Null

py_dpm/views/hierarchy_variables_context.sql

@@ -0,0 +1,14 @@
+CREATE or ALTER VIEW hierarchy_variables_context as
+SELECT distinct vv.VariableVID    as variable_vid,
+                cp.Code           as context_property_code,
+                i.Code            as item_code,
+                mv.StartReleaseID as start_release_id,
+                mv.EndReleaseID   as end_release_id
+FROM VariableVersion vv
+         inner join ContextComposition cc on cc.ContextID = vv.ContextID
+         inner join ItemCategory cp on cp.ItemID = cc.PropertyID and cp.EndReleaseID is Null
+         inner join ItemCategory i on i.ItemID = cc.ItemID and i.EndReleaseID is Null
+         inner join TableVersionCell tvc on vv.VariableVID = tvc.VariableVID
+         inner join TableVersion tv on tvc.TableVID = tv.TableVID
+         inner join ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
+         inner join ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID;

py_dpm/views/key_components.sql

@@ -0,0 +1,18 @@
+CREATE OR ALTER VIEW key_components AS
+select tv.Code           as table_code,
+       ic.Code           as property_code,
+       dt.Code           as data_type,
+       tv.TableVID       as table_version_id,
+       ic.StartReleaseID as start_release_ic,
+       ic.EndReleaseID   as end_release_ic,
+       mv.StartReleaseID as start_release_mv,
+       mv.EndReleaseID   as end_release_mv
+from [dbo].TableVersion tv
+         inner join [dbo].KeyComposition kc on tv.KeyID = kc.KeyID
+         inner join [dbo].VariableVersion vv on vv.VariableVID = kc.VariableVID
+         inner join [dbo].Item i on vv.PropertyID = i.ItemID
+         inner join [dbo].ItemCategory ic on ic.ItemID = i.ItemID
+         inner join [dbo].Property p on vv.PropertyID = p.PropertyID
+         left join [dbo].DataType dt on p.DataTypeID = dt.DataTypeID
+         inner join [dbo].ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
+         inner join [dbo].ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID;

py_dpm/views/module_from_table.sql

@@ -0,0 +1,11 @@
+CREATE OR ALTER VIEW module_from_table AS
+SELECT MV.Code      as module_code,
+       TV.Code     as table_code,
+       MV.FromReferenceDate as from_date,
+       MV.ToReferenceDate   as to_date
+from Module m
+         inner join ModuleVersion MV on m.ModuleID = MV.ModuleID
+         inner join ModuleVersionComposition MVC
+                    on MV.ModuleVID = MVC.ModuleVID
+         inner join TableVersion TV on MVC.TableVID = TV.TableVID
+where TV.Code is not null;

py_dpm/views/open_keys.sql

@@ -0,0 +1,13 @@
+CREATE
+OR ALTER
+VIEW open_keys AS
+select ic.Code           as property_code,
+       dt.Code           as data_type,
+       ic.StartReleaseID as start_release,
+       ic.EndReleaseID   as end_release
+from [dbo].KeyComposition kc
+         inner join [dbo].VariableVersion vv on vv.VariableVID = kc.VariableVID
+         inner join [dbo].Item i on vv.PropertyID = i.ItemID
+         inner join [dbo].ItemCategory ic on ic.ItemID = i.ItemID
+         inner join [dbo].Property p on vv.PropertyID = p.PropertyID
+         left join [dbo].DataType dt on p.DataTypeID = dt.DataTypeID;