base support for Pydal table definition

Author: xnuinside

CHANGELOG.txt

@@ -1,3 +1,6 @@
+**v0.5.0**
+1. Added base support for Pydal tables definition
+
 **v0.4.0**
 1. return tuples (multiple values) is parsed correctly now
 2. symbols like `*&^%$#!±~`§<>` now does not cause any errors

README.md

@@ -2,22 +2,22 @@
 
 ![badge1](https://img.shields.io/pypi/v/py-models-parser) ![badge2](https://img.shields.io/pypi/l/py-models-parser) ![badge3](https://img.shields.io/pypi/pyversions/py-models-parser) ![workflow](https://github.com/xnuinside/py-models-parser/actions/workflows/main.yml/badge.svg)
 
-
 It's as second Parser that done by me, first is a https://github.com/xnuinside/simple-ddl-parser for SQL DDL with different dialects.
 
-Py-Models-Parser can parse & extract information from models:
+Py-Models-Parser can parse & extract information from models & table definitions:
 
-- Sqlalchemy ORM,
-- Gino ORM,
-- Tortoise ORM,
-- Django ORM Model,
-- Pydantic,
-- Python Enum,
-- Pony ORM,
-- Python Dataclasses
-- pure Python Classes
+- Sqlalchemy ORM (https://docs.sqlalchemy.org/en/14/orm/),
+- Gino ORM (https://python-gino.org/),
+- Tortoise ORM (https://tortoise-orm.readthedocs.io/en/latest/),
+- Django ORM Model (https://docs.djangoproject.com/en/3.2/topics/db/queries/),
+- Pydantic (https://pydantic-docs.helpmanual.io/),
+- Python Enum (https://docs.python.org/3/library/enum.html),
+- Pony ORM (https://ponyorm.org/),
+- Pydal Tables definitions (http://www.web2py.com/books/default/chapter/29/06/the-database-abstraction-layer#The-DAL-A-quick-tour),
+- Python Dataclasses (https://docs.python.org/3/library/dataclasses.html),
+- pure Python Classes (https://docs.python.org/3/tutorial/classes.html#class-objects)
 
-Number of supported models will be increased, check 'TODO' section.
+Number of supported models will be increased, check 'TODO' section, if you want to have support of different models types - please open the issue.
 
 Py-Models-Parser written with PEG parser and it's python implementation - parsimonious. It's pretty new and I did not cover all possible test cases, so if you will have an issue  - please just open an issue in this case with example, I will fix it as soon as possible.
 
@@ -171,10 +171,10 @@ For model from point 1 (above) library will produce the result:
 
 ## TODO: in next Release
 
-1. Add more tests for supported models (and fix existed not covered cases): Django ORM, Pydantic, Enums, Dataclasses, SQLAlchemy Models, GinoORM models, TortoiseORM models
+1. Add more tests for supported models (and fix existed not covered cases): Django ORM, Pydantic, Enums, Dataclasses, SQLAlchemy Models, GinoORM models, TortoiseORM models, PonyORM, Pydal tables definitions
 2. Add support for SQLAlchemy Core Tables
-3. Add support for Pony ORM models
-4. Add support for Piccolo ORM models
+3. Add support for Piccolo ORM models
+
 
 ## Changelog
 **v0.4.0**

py_models_parser/visitor.py

@@ -1,4 +1,4 @@
-from typing import Dict, Tuple
+from typing import Dict, List, Tuple, Union
 
 from parsimonious.nodes import NodeVisitor
 
@@ -47,10 +47,10 @@ def extract_orm_attr(self, text: str):
         default = None
         not_orm = True
         properties = {}
-        orm_columns = ["Column", "Field", "relationship", "ForeignKey"]
+        orm_triggers = ["Column", "Field", "relationship", "ForeignKey"]
         pony_orm_fields = ["Required", "Set", "Optional", "PrimaryKey"]
-        orm_columns.extend(pony_orm_fields)
-        for i in orm_columns:
+        orm_triggers.extend(pony_orm_fields)
+        for i in orm_triggers:
             if i in text:
                 not_orm = False
                 # in case of models
@@ -112,6 +112,50 @@ def extractor(self, text: str) -> Dict:
     def visit_right_part(self, node, visited_children):
         return self.extractor(node.text.strip())
 
+    def visit_call_result(self, node, visited_children):
+        value = node.text.strip()
+        if "define_table" in value:
+            # mean this is a pydal method
+            return self.process_pydal_table_definition(value)
+        return visited_children or node
+
+    @staticmethod
+    def process_pydal_table_definition(pydal_def: str) -> Dict:
+        table_def = {
+            "attrs": [],
+            "name": "name",
+            "properties": {},
+        }
+        pydal_def = pydal_def.split("Field(")
+        table_def["name"] = pydal_def[0].split(",")[0].split("define_table(")[1]
+        for column in pydal_def[1:]:
+            column = column.replace(")", "").strip().split(",")
+            column_name = column[0]
+            default = None
+            _type = None
+            properties = {}
+            for num, param in enumerate(column[1:]):
+                param = param.strip().split("=")
+                if len(param) > 1:
+                    if "default" == param[0]:
+                        default = param[1]
+                    elif "type" == param[0]:
+                        _type = param[1]
+                    else:
+                        properties[param[0]] = param[1]
+                else:
+                    if num == 0 and param[0]:
+                        _type = param[0]
+            table_def["attrs"].append(
+                {
+                    "name": column_name,
+                    "default": default,
+                    "type": _type,
+                    "properties": properties,
+                }
+            )
+        return table_def
+
     def visit_attr_def(self, node, visited_children):
         """Makes a dict of the section (as key) and the key/value pairs."""
         left = node.children[1].children[0].children[0].text.strip()
@@ -137,33 +181,34 @@ def visit_attr_def(self, node, visited_children):
                     attr["attr"]["type"] = children[-1]["type"]
         return attr
 
-    def process_chld(self, child, final_child):
-        if "attr" in child and child["attr"]["name"]:
-            # todo: this is a hack, need refactor it
-            if child["attr"]["name"] == "self" and not final_child["properties"].get(
-                "init"
-            ):
-                final_child["properties"]["init"] = []
-            elif "tablename" in child["attr"]["name"]:
-                final_child["properties"]["table_name"] = child["attr"]["default"]
-            elif "table_args" in child["attr"]["name"]:
-                final_child["properties"][child["attr"]["name"]] = (
-                    child["attr"]["type"] or child["attr"]["default"]
-                )
-            else:
-                if final_child["properties"].get("init") is not None:
-                    final_child["properties"]["init"].append(child["attr"])
-                else:
-                    final_child["attrs"].append(child["attr"])
+    @staticmethod
+    def _process_attr(attr: Dict, final_item: Dict) -> Dict:
+        # todo: this is a hack, need refactor it
+        if attr["name"] == "self" and not final_item["properties"].get("init"):
+            final_item["properties"]["init"] = []
+        elif "tablename" in attr["name"]:
+            final_item["properties"]["table_name"] = attr["default"]
+        elif "table_args" in attr["name"]:
+            final_item["properties"][attr["name"]] = attr["type"] or attr["default"]
         else:
+            if final_item["properties"].get("init") is not None:
+                final_item["properties"]["init"].append(attr)
+            else:
+                final_item["attrs"].append(attr)
+        return final_item
 
-            if "attr" in child:
-                final_child = process_no_name_attrs(final_child, child)
-            elif isinstance(child, dict):
-                final_child.update(child)
-            elif isinstance(child, list):
-                for i in child:
-                    final_child = self.process_chld(i, final_child)
+    def process_chld(self, child: Union[Dict, List], final_child: Dict) -> Dict:
+        if child:
+            if "attr" in child and child["attr"].get("name"):
+                final_child = self._process_attr(child["attr"], final_child)
+            else:
+                if "attr" in child:
+                    final_child = process_no_name_attrs(final_child, child)
+                elif isinstance(child, dict):
+                    final_child.update(child)
+                elif isinstance(child, list):
+                    for i in child:
+                        final_child = self.process_chld(i, final_child)
         return final_child
 
     def visit_expr(self, node, visited_children):