dprojectstools 0.0.30__tar.gz → 0.0.32__tar.gz

{dprojectstools-0.0.30/src/dprojectstools.egg-info → dprojectstools-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dprojectstools
-Version: 0.0.30
+Version: 0.0.32
 Summary: A set of development tools
 Author-email: Marc Delos <marcdp@dprojects.com>
 License-Expression: MIT

{dprojectstools-0.0.30 → dprojectstools-0.0.32}/pyproject.toml

@@ -10,7 +10,7 @@ where = ["src"]
 
 [project]
 name = "dprojectstools"
-version = "0.0.30"
+version = "0.0.32"
 authors = [
   { name="Marc Delos", email="marcdp@dprojects.com" },
 ]

{dprojectstools-0.0.30 → dprojectstools-0.0.32}/src/dprojectstools/commands/commands.py

@@ -131,6 +131,26 @@ class CommandsManager:
             #        self.registerFunction(instance, obj, prefix)
         self._registerOrder += 1
 
+    def registerDirectory(self, directory: str, prefix: str = ""):
+        # register main decorated functions from all modules in a directory
+        directory = os.path.abspath(directory)
+        for filename in sorted(os.listdir(directory)):
+            if not filename.endswith(".py") or filename.startswith("_") or filename == "__init__.py":
+                continue
+
+            file_path = os.path.join(directory, filename)
+            module_name = f"_cmd_{os.path.splitext(filename)[0]}"
+
+            spec = importlib.util.spec_from_file_location(module_name, file_path)
+            if spec is None or spec.loader is None:
+                raise ImportError(f"Cannot load module from: {file_path}")
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            self.register(module=module, prefix=prefix)
+                
     def registerFunction(self, instance, func, prefix: str = ""):
         # create a command fron function
         func_name = func.__name__
@@ -215,14 +235,19 @@ class CommandsManager:
                 metadata = param.annotation.__metadata__[0]
                 flag_char = metadata.chr
             # required
-            flag_required = (param.default == inspect.Parameter.empty or param.default == None)
+            # flag_required = (param.default == inspect.Parameter.empty or param.default == None)
+            flag_required = (param.default == inspect.Parameter.empty)
+            if command_name[0] == "module" and command_name[1] == "build":
+                flag_required = flag_required
+
             #  type
             flag_type = None
             if hasattr(param.annotation, "__metadata__"):
                 flag_type = param.annotation.__origin__.__name__
             # argument default
             flag_default = None
-            if param.default != inspect.Parameter.empty and param.default != None:
+            # if param.default != inspect.Parameter.empty and param.default != None:
+            if param.default != inspect.Parameter.empty:
                 flag_default = param.default
             # crea CommandFlag
             flag = CommandFlag(flag_name, flag_alias, flag_title, flag_subtitle, flag_required, flag_type, flag_default, flag_char)
@@ -519,6 +544,16 @@ class CommandsManager:
         # subcommands
         if len(subcommands) > 0:
             print("Commands:")
+            # compute indent_subcommands
+            for subcommand in subcommands:
+                subcommand_name = subcommand.name
+                if command != None:
+                    subcommand_name = subcommand_name[len(command.name):]
+                if subcommand.alias != None:
+                    subcommand_name = subcommand.alias
+                if indent_subcommands < len(' '.join(subcommand_name)) + 2:
+                    indent_subcommands = len(' '.join(subcommand_name)) + 2 
+            # print
             for subcommand in subcommands:
                 subcommand_name = subcommand.name
                 if command != None:
@@ -640,11 +675,13 @@ class CommandsManager:
         
         # exec Command
         command_to_execute = None
+        command_to_execute_args_len = 0
         for command in reversed(self._commands):
             command_name = command.alias if command.alias else command.name
             if len(command_name) <= len(self._argv) - 1:
                 if command_name == self._argv[1:len(command_name)+1]:
                     command_to_execute = command
+                    command_to_execute_args_len = len(command_name)
                     break
             if command_to_execute:
                 break
@@ -700,7 +737,8 @@ class CommandsManager:
                     self._argv.append("--" + flag.alias)
                     self._argv.append(flag_value_separator.join(flag_values))
         # read flags
-        command_args = self._argv[len(command_to_execute.name)+1:]
+        #command_args = self._argv[len(command_to_execute.name)+1:]
+        command_args = self._argv[command_to_execute_args_len+1:]
         command_args_dict = {}
         command_args_errors = []        
         for flag in command_to_execute.flags:
@@ -741,6 +779,10 @@ class CommandsManager:
                 command_args_dict[flag.name] = flag_value
                 command_args.pop(index + 1)
                 command_args.pop(index)
+        # get invalid flags
+        for argument in command_args:
+            if argument.startswith("-"):
+                command_args_errors.append(f"invalid flag: {argument}")
         # read arguments
         for argument in command_to_execute.arguments:
             argument_value = None
@@ -786,7 +828,10 @@ class CommandsManager:
             return func_bounded(**command_args_dict)
         else:
             # invoke
-            return command_to_execute.func(**command_args_dict)
+            result = command_to_execute.func(**command_args_dict)
+            if isinstance(result, bool):
+                result = 1 if not result else 0
+            return result
 
         
     

{dprojectstools-0.0.30 → dprojectstools-0.0.32}/src/dprojectstools/console/__init__.py

@@ -3,4 +3,5 @@ from .sequences import Sequences
 from .keys import Keys
 from .readKey import readKey
 from .read_password import read_password
+from .output import print_info, print_warning, print_error, print_table, print_yaml
 

dprojectstools-0.0.32/src/dprojectstools/console/output.py

@@ -0,0 +1,97 @@
+import sys
+import yaml
+from dataclasses import asdict, is_dataclass
+from .sequences import *
+from pathlib import Path
+
+# print utils
+def print_info(message: str = "") -> None:
+    GRAY = "\033[90m"
+    RESET = "\033[0m"
+    if sys.stdout.isatty():
+        print(f"{GRAY}{message}{RESET}", file=sys.stdout, flush=True)
+    else:
+        print(message, file=sys.stdout, flush=True)
+
+def print_warning(message: str = "") -> None:
+    YELLOW = "\033[33m"
+    RESET = "\033[0m"
+    if sys.stdout.isatty():
+        print(f"{YELLOW}{message}{RESET}", file=sys.stderr, flush=True)
+    else:
+        print(message, file=sys.stdout, flush=True)
+
+def print_error(message: str = "") -> None:
+    RED = "\033[31m"
+    RESET = "\033[0m"
+    if sys.stdout.isatty():
+        print(f"{RED}{message}{RESET}", file=sys.stderr, flush=True)
+    else:
+        print(message, file=sys.stderr, flush=True)
+
+def print_table(items, fields) -> str:
+    def resolve_value(item, field_path):
+        value = item
+        for part in field_path.split("."):
+            if isinstance(value, dict):
+                value = value.get(part, "")
+            else:
+                value = getattr(value, part, "")
+        return value
+    def normalize_value(value):
+        if isinstance(value, list):
+            return ", ".join(str(x) for x in value)
+        return str(value)
+
+    headers = [field.split(".")[-1].upper() for field in fields]
+
+    rows = []
+    for item in items:
+        row = []
+        for field in fields:
+            value = resolve_value(item, field)
+            row.append(normalize_value(value))
+        rows.append(row)
+
+    widths = []
+    for i, header in enumerate(headers):
+        width = len(header)
+        for row in rows:
+            width = max(width, len(row[i]))
+        widths.append(width)
+
+    header_line = "  ".join(headers[i].ljust(widths[i]) for i in range(len(headers)))
+    sep_line = "  ".join("-" * widths[i] for i in range(len(headers)))
+    body_lines = [
+        "  ".join(row[i].ljust(widths[i]) for i in range(len(fields)))
+        for row in rows
+    ]
+    print("\n".join([header_line, sep_line] + body_lines))
+
+
+# yaml utils
+def to_yaml_safe(value):
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, dict):
+        return {k: to_yaml_safe(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [to_yaml_safe(v) for v in value]
+    if isinstance(value, tuple):
+        return [to_yaml_safe(v) for v in value]
+    return value
+
+class IndentYamlDumper(yaml.SafeDumper):
+    def increase_indent(self, flow=False, indentless=False):
+        return super().increase_indent(flow, False)
+        
+def print_yaml( value: object, indent: int = 2) -> None:
+    if is_dataclass(value):
+        value = asdict(value)
+    value = to_yaml_safe(value)
+    print_info(yaml.dump(value,
+        Dumper=IndentYamlDumper,
+        sort_keys=False,
+        allow_unicode=True,
+        default_flow_style=False,
+        indent=indent))

{dprojectstools-0.0.30 → dprojectstools-0.0.32}/src/dprojectstools/db/db_inspector.py

@@ -6,7 +6,7 @@ def datatype_name_to_class(column_type_name):
         return DataType.Bigint
     elif column_type_name == "BINARY":
         return DataType.Binary
-    elif column_type_name == "BLOB":
+    elif column_type_name == "BLOB" or column_type_name == "IMAGE":
         return DataType.Varbinary
     elif column_type_name == "BOOLEAN" or column_type_name == "BIT":
         return DataType.Boolean
@@ -230,6 +230,14 @@ class Inspector:
 # sql server
 class InspectorSqlServer(Inspector):
 
+    def get_table_names(self):
+        result = []
+        for table in self._inspector.get_table_names():
+            if table == "dtproperties":
+                continue
+            result.append(table)
+        return result
+
     def get_database_collation(self):
         return self.execute_scalar("SELECT DATABASEPROPERTYEX(DB_NAME(), 'Collation') AS Collation")
     
@@ -244,7 +252,10 @@ class InspectorSqlServer(Inspector):
     def get_procedure_names(self):
         result = []
         for row in self.execute_fetchall("SELECT name FROM sys.procedures ORDER BY name"):
-            result.append(row[0])
+            name = row[0]
+            if name.startswith("sp_") or name.startswith("fn_") or name.startswith("xp_") or name.startswith("dt_"):
+                continue
+            result.append(name)
         return result
 
     def get_procedure(self, procedure_name):
@@ -281,7 +292,6 @@ class InspectorPostgresql(Inspector):
 class InspectorOracle(Inspector):
     
     
-    
     def get_database_collation(self):
         return self.execute_scalar("SELECT VALUE FROM NLS_DATABASE_PARAMETERS WHERE PARAMETER = 'NLS_CHARACTERSET'")
     def get_table_names(self):

{dprojectstools-0.0.30 → dprojectstools-0.0.32}/src/dprojectstools/db/db_schema.py

@@ -2,6 +2,7 @@ from xml.etree import ElementTree
 from xml.dom import minidom
 from dataclasses import dataclass
 from enum import Enum
+from flask import json
 from lxml import etree
 import os
 
@@ -35,7 +36,9 @@ class DataType(Enum):
         for member in DataType:
             if member.name.lower() == value:
                 return member
-            
+    def to_str(self):        
+        return self.name.lower()
+
 class OnDelete(Enum):
     NO_ACTION = 1
     CASCADE = 2
@@ -158,7 +161,7 @@ class Schema:
         self.scripts = []
 
     # static methods
-    def create(source: str, create_inspector):
+    def create(source: str, create_inspector = None):
         if os.path.exists(source):
             with open(source, "r", encoding='utf-8') as file:
                 xml = file.read()

dprojectstools-0.0.32/src/dprojectstools/db/generator_json.py

@@ -0,0 +1,140 @@
+import json
+from xml.etree import ElementTree
+from xml.dom import minidom
+from xml.sax.saxutils import escape
+from .db_schema import OnDelete, OnUpdate
+ 
+def remove_none(obj):
+    if isinstance(obj, dict):
+        return {
+            k: remove_none(v)
+            for k, v in obj.items()
+            if v is not None
+        }
+    elif isinstance(obj, list):
+        return [
+            remove_none(item)
+            for item in obj
+            if item is not None
+        ]
+    else:
+        return obj
+    
+
+class GeneratorJson:
+
+    def __init__(self, schema):
+        self._separator = ";"
+        self._schema = schema
+
+    def create(schema):
+        return GeneratorJson(schema)
+
+    def generate(self):
+        xml_database = ElementTree.Element("database")
+        result = {
+            "name": self._schema.name,
+            "description": self._schema.description if self._schema.description else None,
+            "collation": self._schema.collation if self._schema.collation else None,
+            "tables": [],
+            "views": [],
+            "procedures": [],
+            "sequences": [],
+            "scripts": []
+        }
+        for table in self._schema.tables:
+            tableDict = {
+                "description": table.description if table.description else None,
+                "columns": [],
+                "primary_key": {
+                    "name": table.primary_key.name,
+                    "description": table.primary_key.description if table.primary_key.description else None,
+                    "columns": table.primary_key.columns
+                } if table.primary_key else None,
+                "foreign_keys": [],
+                "indexes": [],
+                "records": []
+            }
+            result["tables"].append({table.name: tableDict})
+            for column in table.columns:
+                columnDict = {
+                    "name": column.name,
+                    "description": column.description if column.description else None,
+                    "data_type": column.data_type.to_str(),
+                    "is_autoincrement": True if column.is_autoincrement else None,
+                    "null": True if column.null else None,
+                    "size": column.size if column.size > 0 else None,
+                    "default": column.default if column.default else None,
+                    "precision": column.precision if column.precision > 0 else None,
+                    "scale": column.scale if column.scale > 0 else None,
+                    "collation": column.collation if column.collation else None
+                }
+                tableDict["columns"].append(columnDict)
+            for foreign_key in table.foreign_keys:
+                foreignKeyDict = {
+                    "name": foreign_key.name,
+                    "description": foreign_key.description if foreign_key.description else None,
+                    "columns": foreign_key.columns,
+                    "ref_table": foreign_key.ref_table,
+                    "ref_columns": foreign_key.ref_columns,
+                    "on_delete": foreign_key.on_delete.name if foreign_key.on_delete != OnDelete.NO_ACTION else None,
+                    "on_update": foreign_key.on_update.name if foreign_key.on_update != OnUpdate.NO_ACTION else None
+                }
+                tableDict["foreign_keys"].append(foreignKeyDict)
+            for index in table.indexes:
+                indexDict = {
+                    "name": index.name,
+                    "description": index.description if index.description else None,
+                    "unique": index.unique if index.unique else None,
+                    "columns": index.columns
+                }
+                tableDict["indexes"].append(indexDict)
+            for record in table.records:
+                recordDict = {
+                    "values": record.values
+                }
+                tableDict["records"].append(recordDict)
+        for view in self._schema.views:
+            viewDict = {
+                "name": view.name,
+                "description": view.description if view.description else None,
+                "content": view.content
+            }
+            result["views"].append(viewDict)
+        for procedure in self._schema.procedures:
+            procedureDict = {
+                "name": procedure.name,
+                "description": procedure.description if procedure.description else None,
+                "arguments": [],
+                "content": procedure.content
+            }
+            result["procedures"].append(procedureDict)
+            for argument in procedure.arguments:
+                argumentDict = {
+                    "name": argument.name,
+                    "description": argument.description if argument.description else None,
+                    "data_type": argument.data_type.to_str(),
+                    "size": argument.size if argument.size > 0 else None,
+                    "precision": argument.precision if argument.precision > 0 else None,
+                    "scale": argument.scale if argument.scale > 0 else None,
+                    "null": True if argument.null else None,
+                    "direction": argument.direction
+                }
+                procedureDict["arguments"].append(argumentDict)
+        for sequence in self._schema.sequences:
+            sequenceDict = {
+                "name": sequence.name,
+                "description": sequence.description if sequence.description else None,
+                "init_value": sequence.init_value,
+                "increment_by": sequence.increment_by
+            }
+            result["sequences"].append(sequenceDict)
+        for script in self._schema.scripts:
+            scriptDict = {
+                "name": script.name,
+                "description": script.description if script.description else None,
+                "content": script.content
+            }
+            result["scripts"].append(scriptDict)        
+        clean_obj = remove_none(result)
+        return json.dumps(clean_obj, indent=4)

dprojectstools-0.0.32/src/dprojectstools/db/generator_sql.py

@@ -0,0 +1,237 @@
+from .db_schema import OnDelete, OnUpdate
+
+class GeneratorSql:
+
+    def __init__(self, schema):
+        self._separator = ";"
+        self._schema = schema
+
+    # methods
+    def create(schema):
+        return GeneratorSql(schema)
+
+    # to override
+    def identity(self):
+        return "IDENTITY"
+    def default(self, value):
+        if value == "now":
+            return "getDate()"
+        return value
+    def data_type_name(self, column):
+        return column.data_type.name.upper()
+    def disable_foreign_keys(self):
+        return ""    
+    def enable_foreign_keys(self):
+        return ""
+
+    # methods
+    def generate(self):
+        sql = []
+        for table in self._schema.tables:
+            sql.append(self.create_table(table))
+        # fks
+        sql.append(f"--- fks")
+        for table in self._schema.tables:
+            for foreign_key in table.foreign_keys:
+                line = self.create_table_foreign_key(table, foreign_key)
+                sql.append(line)
+        # inserts
+        sql.append(f"--- inserts")
+        for table in self._schema.tables:
+            for record in table.records:
+                sql.append(self.insert_record(table, record))
+        # return
+        return "\n".join(sql)
+    
+    def create_table(self, table):
+        sql = []
+        sql.append(f"--- table {table.name}")
+        sql.append(f"CREATE TABLE {table.name} (")
+        column_index = 0
+        for column in table.columns:
+            line = []
+            line.append("  ")
+            line.append(column.name)
+            if column.precision > 0 or column.scale > 0:
+                line.append(f"{self.data_type_name(column)}({column.precision},{column.scale})")
+            elif column.size > 0:
+                line.append(f"{self.data_type_name(column)}({column.size})")
+            else:
+                line.append(f"{self.data_type_name(column)}")
+            if column.is_autoincrement:
+                line.append(self.identity())
+            if column.null:
+                line.append(f"NULL")
+            else:
+                line.append(f"NOT NULL")
+            if column.default != None:
+                line.append(f" DEFAULT {self.default(column.default)}")
+            if column.description != "":
+                line.append(f"--- {column.description}")
+            sql.append(" ".join(line) + ",")
+            column_index += 1
+        if table.primary_key != None:
+            sql.append(f"   PRIMARY KEY ({",".join(table.primary_key.columns)}), ")
+        sql.append(f"){self._separator}")        
+        for index in table.indexes:
+            sql.append(self.create_table_index(table, index))
+        return "\n".join(sql)
+
+    def alter_table(self, table):
+        return ""
+
+    def drop_table(self, table):
+        return f"DROP TABLE {table.name}{self._separator}"
+    
+    def create_table_foreign_key(self, table, foreign_key):
+        line = f"ALTER TABLE {table.name} ADD CONSTRAINT {foreign_key.name} FOREIGN KEY ({",".join(foreign_key.columns)}) REFERENCES {foreign_key.ref_table} ({",".join(foreign_key.ref_columns)}) "
+        if foreign_key.on_delete != OnDelete.NO_ACTION:
+            line += "ON DELETE " + foreign_key.on_delete.name.replace("_"," ")
+        if foreign_key.on_update != OnUpdate.NO_ACTION:
+            line += "ON UPDATE " + foreign_key.on_update.name.replace("_"," ")
+        return line + self._separator
+    
+    def create_table_index(self, table, index):
+        return f"CREATE {"UNIQUE" if index.unique else ""} INDEX {index.name} ON {table.name} ({' '.join(index.columns)}){self._separator}"
+    
+    def insert_record(self, table, record):
+        sql = []
+        sql.append(f"INSERT INTO {table.name} (")
+        index = 0
+        for key in record.values:
+            if index > 0:
+                sql.append(",")
+            sql.append(key)
+            index += 1
+        sql.append(") VALUES (")
+        index = 0
+        for key in record.values:
+            if index > 0:
+                sql.append(",")
+            value = record.values[key]
+            sql.append(self.format_value(value))
+            index += 1
+        sql.append(f"){self._separator}")
+        return " ".join(sql)
+    
+    def format_value(self, value):
+        return "'" + value.replace("'","''") + "'"
+    
+    def create_view(self, view):
+        pass
+    def alter_view(self, view):
+        pass
+    def drop_view(self, view):
+        pass
+
+    def create_procedure(self, procedure):
+        pass
+    def alter_procedure(self, procedure):
+        pass
+    def drop_procedure(self, procedure):
+        pass
+
+    def create_sequence(self, sequence):
+        pass
+    def alter_sequence(self, sequence):
+        pass
+    def drop_sequence(self, sequence):
+        pass
+
+    def generate_diff(self, other_schema):
+        result = []
+        for table in self._schema.tables:
+            # get table with same name in other schema
+            other_table = None
+            for target_table in other_schema.tables:
+                if target_table.name == table.name:
+                    other_table = target_table
+                    break
+            # if not found, create table
+            if other_table == None:
+                result.append(self.create_table(table))
+                # add fks
+                for foreign_key in table.foreign_keys:
+                    result.append(self.create_table_foreign_key(table, foreign_key))
+                # add indexes
+                for index in table.indexes:
+                    result.append(self.create_table_index(table, index))
+                continue
+            else:
+                # add new columns
+                for column in table.columns:
+                    other_column = None
+                    for target_column in other_table.columns:
+                        if target_column.name == column.name:
+                            other_column = target_column
+                            break
+                    if other_column == None:
+                        result.append(self.alter_table(table))
+                # drop unexisting old columns
+                pass
+                # change columns data types, defaults, nulls, autoincrements, ...
+                pass
+       
+        # create fks
+        for table in self._schema.tables:
+            # get table with same name in other schema
+            other_table = None
+            for target_table in other_schema.tables:
+                if target_table.name == table.name:
+                    other_table = target_table
+                    break
+            # for each fk 
+            if other_table != None:
+                for foreign_key in table.foreign_keys:
+                    other_foreign_key = None
+                    for target_foreign_key in other_table.foreign_keys:
+                        if target_foreign_key.name == foreign_key.name:
+                            other_foreign_key = target_foreign_key
+                            break
+                    if other_foreign_key == None:
+                        result.append(self.create_table_foreign_key(table, foreign_key))            
+                # drop unexisting foreign keys
+                pass
+        # create indexes
+        for table in self._schema.tables:
+            # get table with same name in other schema
+            other_table = None
+            for target_table in other_schema.tables:
+                if target_table.name == table.name:
+                    other_table = target_table
+                    break
+            # for each index
+            if other_table != None:
+                for index in table.indexes:
+                    other_index = None
+                    for target_index in other_table.indexes:
+                        if target_index.name == index.name:
+                            other_index = target_index
+                            break
+                    if other_index == None:
+                        result.append(self.create_table_index(table, index))
+                # drop unexisting indexes
+                pass
+
+        # drop unexisting tables
+        for table in other_schema.tables:
+            # get table with same name in other schema
+            other_table = None
+            for target_table in self._schema.tables:
+                if target_table.name == table.name:
+                    other_table = target_table
+                    break
+            # if not found, drop table
+            if other_table == None:
+                result.append(self.drop_table(table))
+                continue        
+        # return
+        return "\n".join(result)
+
+class GeneratorSqlSqllite(GeneratorSql):
+    
+    def disable_foreign_keys(self):
+        return "PRAGMA foreign_keys = OFF;"
+    
+    def enable_foreign_keys(self):
+        return "PRAGMA foreign_keys = ON;"