add support for differen pydal properties & python lists

Author: xnuinside

CHANGELOG.txt

@@ -1,5 +1,6 @@
 **v0.5.0**
 1. Added base support for Pydal tables definition
+2. Added support for python list syntax like []
 
 **v0.4.0**
 1. return tuples (multiple values) is parsed correctly now

README.md

@@ -171,12 +171,16 @@ 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, PonyORM, Pydal tables definitions
+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, for lists
 2. Add support for SQLAlchemy Core Tables
 3. Add support for Piccolo ORM models
 
 
 ## Changelog
+**v0.5.0**
+1. Added base support for Pydal tables definition
+2. Added support for python list syntax like []
+
 **v0.4.0**
 1. return tuples (multiple values) is parsed correctly now
 2. symbols like `*&^%$#!±~`§<>` now does not cause any errors

docs/README.rst

@@ -22,20 +22,21 @@ Py-Models-Parser
 
 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.
 
@@ -193,14 +194,19 @@ TODO: in next Release
 ---------------------
 
 
-#. Add more tests for supported models (and fix existed not covered cases): Django ORM, Pydantic, Enums, Dataclasses, SQLAlchemy Models, GinoORM models, TortoiseORM models
+#. Add more tests for supported models (and fix existed not covered cases): Django ORM, Pydantic, Enums, Dataclasses, SQLAlchemy Models, GinoORM models, TortoiseORM models, PonyORM, for lists
 #. Add support for SQLAlchemy Core Tables
-#. Add support for Pony ORM models
 #. Add support for Piccolo ORM models
 
 Changelog
 ---------
 
+**v0.5.0**
+
+
+#. Added base support for Pydal tables definition
+#. Added support for python list syntax like []
+
 **v0.4.0**
 
 

py_models_parser/grammar.py

@@ -15,9 +15,10 @@ class = class_def attr_def* funct_def*
     string = one_quote_str / double_quotes_str
     one_quote_str = ~"\'[^\']+\'"i
     double_quotes_str = ~'"[^\"]+"'i
+    list = "[" (call_result / attr_def / args / id / text)* ","* "]"
     funct_def = intend? "def" id args? ":"* ws?
     args_in_brackets = "[" ((id/string)* ","* )* "]"
-    args        = "(" (( call_result / args / attr_def / id  )* ","* )* ")"
+    args        = "(" (( list / call_result / args  / attr_def / id  )* ","* )* ")"
     call_result = id args ws?
     class_name  = "class" id
     id          = (((dot_id / text)+ ) *  / dot_id / text) ws?

py_models_parser/parsers/pydal.py

@@ -0,0 +1,76 @@
+from typing import Dict, List
+
+pydal_order_field_args = {
+    1: "length",
+    3: "required",
+    4: "requires",
+    5: "ondelete",
+    6: "notnull",
+    7: "unique",
+}
+
+
+def _pydal_table_properties(table_def: Dict, value: str) -> Dict:
+    table_prop = value.split(",")
+    previos_prop = None
+    for num, prop in enumerate(table_prop):
+        if num == len(table_prop) - 1:
+            prop = prop.replace(")", "")
+        prop = prop.strip().split("=")
+        if len(prop) > 1:
+            table_def["properties"][prop[0].strip()] = prop[1].strip()
+            previos_prop = prop[0].strip()
+        else:
+            # like lists
+            table_def["properties"][previos_prop] += f", {prop[0]}"
+
+    return table_def
+
+
+def pydal_column_properties(attr: Dict, column: List) -> Dict:
+    properties = {}
+    default = None
+    _type = None
+    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 param[0]:
+                if num == 0:
+                    _type = param[0]
+                elif num == 2:
+                    default = param[0]
+                else:
+                    order_param = pydal_order_field_args.get(num)
+                    if order_param:
+                        properties[order_param] = param[0]
+
+    attr.update({"properties": properties, "default": default, "type": _type})
+    return attr
+
+
+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.strip().replace(") ,", "),").split("),")
+        if len(_column) == 2 and _column[-1] != "":
+            table_def = _pydal_table_properties(table_def, _column[-1])
+        column = column.replace(")", "").strip().split(",")
+        column_name = column[0]
+        attr = {"name": column_name}
+        attr = pydal_column_properties(attr, column)
+        table_def["attrs"].append(attr)
+    return table_def

py_models_parser/visitor.py

@@ -2,6 +2,8 @@
 
 from parsimonious.nodes import NodeVisitor
 
+from py_models_parser.parsers.pydal import process_pydal_table_definition
+
 
 class Visitor(NodeVisitor):
     def visit_class_name(self, node, visited_children):
@@ -116,46 +118,9 @@ 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 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()

pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "py-models-parser"
-version = "0.4.0"
-description = "Parser for Different Python Models (Pydantic, Enums, ORMs: Tortoise, SqlAlchemy, GinoORM, PonyORM) to extract information about columns(attrs), model, table args,etc in one format."
+version = "0.5.0"
+description = "Parser for Different Python Models (Pydantic, Enums, ORMs: Tortoise, SqlAlchemy, GinoORM, PonyORM, Pydal tables) to extract information about columns(attrs), model, table args,etc in one format."
 authors = ["Iuliia Volkova <xnuinside@gmail.com>"]
 license = "MIT"
 readme = "docs/README.rst"