vtlengine 1.4.0rc2__py3-none-any.whl

vtlengine/API/data/schema/json_schema_2.1.json

@@ -0,0 +1,116 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "description": "VTL Metadata JSON serialization",
+    "$defs": {
+        "vtl-id": {
+            "type": "string",
+            "pattern": "^[a-zA-Z][a-zA-Z0-9_]*$|^'.*'$"
+        },
+        "set-type": {
+            "type": "array",
+            "uniqueItems": true,
+            "oneOf": [
+                { "items": { "oneOf": [ { "type": "string" }, { "type": "null" } ] } },
+                { "items": { "oneOf": [ { "type": "number" }, { "type": "null" } ] } }
+            ]
+        },
+        "identifiable": {
+            "type": "object",
+            "properties": {
+                "name": { "$ref": "#/$defs/vtl-id" },
+                "description": { "type": "string" }
+            },
+            "required": [ "name" ]
+        }
+    },
+    "type": "object",
+    "properties": {
+        "datasets": {
+            "type": "array",
+            "items": {
+                "allOf": [ { "$ref": "#/$defs/identifiable" } ],
+                "properties": {
+                    "source": { "type": "string" },
+                    "structure": { "$ref": "#/$defs/vtl-id" }
+                },
+                "required": [ "structure" ]
+            }
+        },
+        "structures": {
+            "type": "array",
+            "items": {
+                "allOf": [ { "$ref": "#/$defs/identifiable" } ],
+                "properties": {
+                    "components": {
+                        "type": "array",
+                        "items": {
+                            "allOf": [ { "$ref": "#/$defs/identifiable" } ],
+                            "properties": {
+                                "role": {
+                                    "type": "string",
+                                    "enum": [ "Identifier", "Measure", "Attribute", "Viral Attribute" ]
+                                },
+                                "subset": { "$ref": "#/$defs/vtl-id" },
+                                "nullable": { "type": "boolean" },
+                                "data_type": {
+                                    "type": "string",
+                                    "enum": [ "String", "Number", "Integer", "Boolean", "Time", "TimePeriod", "Date", "Duration" ]
+                                }
+                            },
+                            "required": [ "role" ]
+                        }
+                    }
+                },
+                "required": [ "components" ]
+            }
+        },
+        "variables": {
+            "type": "array",
+            "items": {
+                "allOf": [ { "$ref": "#/$defs/identifiable" } ],
+                "properties": {
+                    "domain": { "$ref": "#/$defs/vtl-id" }
+                },
+                "required": [ "domain" ]
+            }
+        },
+        "domains": {
+            "type": "array",
+            "items": {
+                "allOf": [ { "$ref": "#/$defs/identifiable" } ],
+                "unevaluatedProperties": false,
+                "oneOf": [
+                    {
+                        "properties": {
+                            "externalRef": { "type": "string" }
+                        },
+                        "required": [ "externalRef" ]
+                    }, {
+                        "properties": {
+                            "parent": { "$ref": "#/$defs/vtl-id" }
+                        },
+                        "required": [ "parent" ],
+                        "oneOf": [{
+                                "properties": {
+                                    "restriction": { "$ref": "#/$defs/set-type" }
+                                },
+                                "required": [ "restriction" ]
+                            }, {
+                                "properties": {
+                                    "enumerated": { "$ref": "#/$defs/set-type" }
+                                },
+                                "required": [ "enumerated" ]
+                            }, {
+                                "properties": {
+                                    "described": { "type": "string" }
+                                },
+                                "required": [ "described" ]
+                            }
+                        ]
+                    }
+                ]
+            }
+        }
+    }
+}
+

vtlengine/API/data/schema/value_domain_schema.json

@@ -0,0 +1,97 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "ValueDomain": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "Name identifier for the Value Domain"
+        },
+        "setlist": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "description": "List of unique values of the Value Domain"
+        },
+        "type": {
+          "type": "string",
+          "enum": ["Integer", "Number", "String", "Boolean", "Date", "Time_Period", "Time", "Duration"],
+          "description": "Data type of the Value Domain"
+        }
+      },
+      "required": ["name", "setlist", "type"],
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "type": {"const": "Integer"}
+            }
+          },
+          "then": {
+            "properties": {
+              "setlist": {
+                "items": {"type": "integer"}
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "type": {"const": "Number"}
+            }
+          },
+          "then": {
+            "properties": {
+              "setlist": {
+                "items": {"type": "number"}
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "type": {"const": "Boolean"}
+            }
+          },
+          "then": {
+            "properties": {
+              "setlist": {
+                "items": {"type": "boolean"}
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "type": {"enum": ["String", "Date", "Time_Period", "Time", "Duration"]}
+            }
+          },
+          "then": {
+            "properties": {
+              "setlist": {
+                "items": {"type": "string"}
+              }
+            }
+          }
+        }
+      ]
+    }
+  },
+  "oneOf": [
+    {
+      "$ref": "#/definitions/ValueDomain"
+    },
+    {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/ValueDomain"
+      },
+      "minItems": 1
+    }
+  ]
+}

vtlengine/AST/ASTComment.py

@@ -0,0 +1,57 @@
+from antlr4 import CommonTokenStream, InputStream
+from antlr4.Token import CommonToken
+
+from vtlengine.API import create_ast
+from vtlengine.AST import Comment, Start
+from vtlengine.AST.ASTConstructorModules import extract_token_info
+from vtlengine.AST.Grammar.lexer import Lexer
+
+
+def generate_ast_comment(token: CommonToken) -> Comment:
+    """
+    Parses a token belonging to a comment and returns a Comment AST object.
+
+    Args:
+        token (str): The comment string to parse.
+
+    Returns:
+        Comment: A Comment AST object.
+    """
+    token_info = extract_token_info(token)
+    text = token.text
+    if token.type == Lexer.SL_COMMENT:
+        text = token.text[:-1]  # Remove the trailing newline character
+    return Comment(value=text, **token_info)
+
+
+def create_ast_with_comments(text: str) -> Start:
+    """
+    Parses a VTL script and returns an AST with comments.
+
+    Args:
+        text (str): The VTL script to parse.
+
+    Returns:
+        AST: The generated AST with comments.
+    """
+    # Call the create_ast function to generate the AST from channel 0
+    ast = create_ast(text)
+
+    text = text if text.endswith("\n") else text + "\n"
+    # Reading the script on channel 2 to get the comments
+    lexer_ = Lexer(InputStream(text))
+    stream = CommonTokenStream(lexer_, channel=2)
+
+    # Fill the stream with tokens on the buffer
+    stream.fill()
+
+    # Extract comments from the stream
+    comments = [generate_ast_comment(token) for token in stream.tokens if token.channel == 2]
+
+    # Add comments to the AST
+    ast.children.extend(comments)
+
+    # Sort the ast children based on their start line and column
+    ast.children.sort(key=lambda x: (x.line_start, x.column_start))
+
+    return ast