mwgencode 1.5.18__tar.gz → 1.6.0__tar.gz

{mwgencode-1.5.18/mwgencode.egg-info → mwgencode-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mwgencode
-Version: 1.5.18
+Version: 1.6.0
 Summary: 根据starUML文档产生flask专案的代码
 Home-page: https://bitbucket.org/maxwin-inc/gencode/src/
 Author: cxhjet

{mwgencode-1.5.18 → mwgencode-1.6.0}/gencode/gen_code.py

@@ -20,7 +20,7 @@ class GenCode():
         self.modelfile = os.path.abspath(modelfile)
         self.rootpath = os.path.abspath(rootpath)
 
-    def model(self, outfile='models_base.py', type='flask',appdir='app',exists2cover=True):
+    def model(self, writer='self', outfile='models_base.py', type='flask',appdir='app',exists2cover=True):
         '''
         产生基本资料的base类别的代码
         :param outfile: bomodel的文件名
@@ -32,6 +32,10 @@ class GenCode():
             outfile_name = os.path.join(self.rootpath,appdir, outfile)
         else:
             outfile_name = os.path.join(self.rootpath, outfile)
+        # ai 不变更models_base.py,如果outfile_name 已存在,则不变更
+        if writer == 'ai' and os.path.exists(outfile_name):
+            logging.info('提示：AI 写代码,不变更models_base.py')
+            return
         gen_code = Gen_bo_models(self.modelfile,
                                  outfile_name,
                                  type=type)
@@ -128,7 +132,7 @@ class GenProject_Sample(GenProject_base):
     def __init__(self,modelfile,rootpath):
         super().__init__(modelfile,rootpath)
         
-    def gen_code(self,include_gencoderun,project_name=None):
+    def gen_code(self,include_gencoderun,project_name=None,writer='self'):
         p_name = project_name or os.path.split(self.rootpath)[-1]
         if not os.path.exists(self.modelfile):
             if not os.path.exists('docs'):
@@ -148,7 +152,7 @@ class GenProject_Sample(GenProject_base):
         if not os.path.exists(gen_code_yaml):
             template = self.env.get_template(r'gen_code_flask.yaml')
             saveUTF8File(gen_code_yaml,
-                         [template.render(pro_name=p_name,pro_type='flask')])
+                         [template.render(pro_name=p_name,pro_type='flask',writer=writer)])
 
 class GenProject_Aiohttp(GenProject_base):
     def __init__(self,modelfile,rootpath):
@@ -168,11 +172,13 @@ class GenProject_Flask(GenProject_base):
         super().__init__(modelfile,rootpath)
 
     def gen_code(self,
+                 writer:str = 'self',
                  include_swagger:bool=True,
                  include_model:bool=True,
                  include_auth:bool = True,
                  include_test:bool = False,
                  include_seeds:bool = False,
+                 include_migrations:bool = False,
                  need_upgrade:bool = False,
                  use_uwsgi:bool = True,
                  plugins:list = None):
@@ -196,8 +202,16 @@ class GenProject_Flask(GenProject_base):
         # outfile为’‘时，采用默认的路径
         gen = GenSwaggerCodeFromUml(self.rootpath, self.modelfile, type='flask')
         if include_swagger:
-            gen.gen_swagger_code(outfile='')
-            gen.gen_swagger_ctr_code()
+            # 如果是ai writer，在swaggers目录存在时就不产生swagger file,
+            write_swagger = True
+            if writer == 'ai':
+                if os.path.exists(os.path.join(self.rootpath,'swagger')):
+                    logging.info('提示：AI 写代码,不变更swagger file')
+                    write_swagger = False
+
+            if write_swagger:
+                gen.gen_swagger_code(outfile='')
+                gen.gen_swagger_ctr_code()
 
         else:
             logging.info('提示：不产生swagger file')
@@ -326,6 +340,29 @@ class GenProject_Flask(GenProject_base):
             self.save_as(os.path.join(self.sample_path,'seeds', 'seed_utils.pys'),
                          os.path.join(os.path.realpath(self.rootpath),'seeds', 'seed_utils.py'))
 
+        if include_migrations:
+            self.save_as(os.path.join(self.sample_path,'migrations', '__init__.py'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', '__init__.py'))
+            self.save_as(os.path.join(self.sample_path,'migrations', 'alembic.ini'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'alembic.ini'))
+            self.save_as(os.path.join(self.sample_path,'migrations', 'audit.py'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'audit.py'))
+            self.save_as(os.path.join(self.sample_path,'migrations', 'dependency_order.py'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'dependency_order.py'))
+            self.save_as(os.path.join(self.sample_path,'migrations', 'env.py'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'env.py'))
+            self.save_as(os.path.join(self.sample_path,'migrations', 'ownership.py'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'ownership.py'))                
+            self.save_as(os.path.join(self.sample_path,'migrations', 'precheck.py'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'precheck.py'))   
+            self.save_as(os.path.join(self.sample_path,'migrations', 'README'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'README'))   
+            self.save_as(os.path.join(self.sample_path,'migrations', 'safety_policy.py'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'safety_policy.py'))               
+            self.save_as(os.path.join(self.sample_path,'migrations', 'script.py.mako'),
+                         os.path.join(os.path.realpath(self.rootpath),'migrations', 'script.py.mako'))   
+
+
         if include_test:
             gen_test_code = GenTestsCodeFromUml(self.rootpath, self.modelfile, type='flask')
             gen_test_code.gen_tests_codes()

mwgencode-1.6.0/gencode/gencode/sample/migrations/README

@@ -0,0 +1,61 @@
+Flask 单数据库迁移配置说明。
+
+共享数据库安全策略：
+- 在 `migrations/ownership.py` 中配置本服务拥有的表/字段范围。
+- 可选环境变量：`MIGRATION_OWNED_TABLES=table_a,table_b`。
+- 自动差异仅比较“模型定义 + owned 范围”内对象。
+- 所有 `drop_*` 破坏性操作都会被阻断，不会自动执行删除。
+
+迁移阶段说明：
+- `expand`：新增表/字段，执行低风险结构修改。
+- `contract`：执行高风险结构修改（例如收紧 nullable、缩短长度）。
+
+推荐执行顺序（生产）：
+- `flask schema-plan --phase expand`
+- `flask schema-upgrade --phase expand`
+- 发布应用
+- `flask schema-verify --phase contract`
+- `flask schema-upgrade --phase contract`
+
+兼容别名（仍可用，但建议迁移到新命名）：
+- `db-safe-plan`
+- `db-safe-verify`
+- `db-safe-migrate`
+- `db-safe-upgrade`
+
+“同步版本”通常有两种场景，你可以这样做。
+
+```powershell
+# 1) 设置 CLI 入口
+$env:FLASK_APP = "manage:app"
+```
+
+1. **首次接管已有数据库（库里有业务表，但没有 alembic_version）**  
+用这条即可，它会自动做 `stamp head` 再升级：
+```powershell
+flask schema-upgrade --phase expand
+```
+
+2. **你改了 models，想生成“同步变更”的新版本文件**  
+先确保数据库在最新，再生成迁移版本：
+```powershell
+flask schema-migrate --phase expand -m "sync models"
+```
+
+3. **执行并同步到数据库**
+```powershell
+flask schema-upgrade --phase expand
+```
+
+4. **如果有高风险收敛变更（如 nullable 收紧、长度缩短）**
+```powershell
+flask schema-verify --phase contract
+flask schema-upgrade --phase contract
+```
+
+自动生成迁移时的建表顺序规则：
+- 新增表会按外键依赖自动重排，尽量保证被依赖表先创建。
+- 循环依赖用强连通分量（SCC）识别：只把「同一 SCC 内部」的外键延后为 `op.create_foreign_key(...)`；指向 SCC 外部的外键仍内联并参与排序（避免误拆非环依赖）。
+- 单表自引用也属于环，会把该自引用外键单独延后。
+- 如果新增表之间存在循环外键，成环的 FK 会改写为后续 `op.create_foreign_key(...)`，先建表再补约束。
+- 这项改写只影响 autogenerate 生成出的脚本结构，不改变后续 `drop_*` 安全过滤和阶段过滤行为。

mwgencode-1.6.0/gencode/gencode/sample/migrations/__init__.py

@@ -0,0 +1,2 @@
+#
+#

mwgencode-1.6.0/gencode/gencode/sample/migrations/alembic.ini

@@ -0,0 +1,50 @@
+# A generic, single database configuration.
+
+[alembic]
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic,flask_migrate
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[logger_flask_migrate]
+level = INFO
+handlers =
+qualname = flask_migrate
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

mwgencode-1.6.0/gencode/gencode/sample/migrations/audit.py

@@ -0,0 +1,53 @@
+"""
+Schema migration audit helpers.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from sqlalchemy import Column, DateTime, Integer, MetaData, String, Table, Text, text
+
+AUDIT_TABLE = "schema_migration_audit"
+
+
+def ensure_audit_table(engine) -> None:
+    metadata = MetaData()
+    Table(
+        AUDIT_TABLE,
+        metadata,
+        Column("id", Integer, primary_key=True, autoincrement=True),
+        Column("revision", String(64), nullable=False),
+        Column("phase", String(20), nullable=False),
+        Column("status", String(20), nullable=False),
+        Column("payload_json", Text, nullable=True),
+        Column("created_at", DateTime, nullable=False),
+    )
+    metadata.create_all(engine, checkfirst=True)
+
+
+def build_audit_insert_sql(revision: str, phase: str, status: str, payload_json: str) -> str:
+    rev = _escape_sql(revision)
+    phase_val = _escape_sql(phase)
+    status_val = _escape_sql(status)
+    payload = _escape_sql(payload_json)
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    return (
+        f"INSERT INTO {AUDIT_TABLE} (revision, phase, status, payload_json, created_at) "
+        f"VALUES ('{rev}', '{phase_val}', '{status_val}', '{payload}', '{now}')"
+    )
+
+
+def record_migration_audit(engine, revision: str, phase: str, status: str, payload_json: str) -> None:
+    ensure_audit_table(engine)
+    sql = build_audit_insert_sql(
+        revision=revision,
+        phase=phase,
+        status=status,
+        payload_json=payload_json,
+    )
+    with engine.begin() as conn:
+        conn.execute(text(sql))
+
+
+def _escape_sql(value: str | None) -> str:
+    return (value or "").replace("'", "''")

mwgencode-1.6.0/gencode/gencode/sample/migrations/dependency_order.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from alembic.operations import ops
+import sqlalchemy as sa
+
+
+def _table_key(schema, table_name):
+    return (schema, table_name)
+
+
+def _iter_foreign_key_constraints(create_op):
+    for item in create_op.columns:
+        if isinstance(item, sa.ForeignKeyConstraint):
+            yield item
+
+
+def _target_table_key(constraint):
+    target_fullname = constraint.elements[0].target_fullname
+    parts = target_fullname.split(".")
+    if len(parts) < 2:
+        return (None, target_fullname)
+    if len(parts) == 2:
+        return (None, parts[0])
+    return (".".join(parts[:-2]), parts[-2])
+
+
+def _fk_signature(constraint):
+    source_columns = tuple(column.name for column in constraint.columns)
+    target_columns = tuple(element.target_fullname for element in constraint.elements)
+    return (
+        constraint.name,
+        source_columns,
+        target_columns,
+    )
+
+
+def _clone_create_table_op(original_op, deferred_fk_signatures):
+    items = []
+    for item in original_op.columns:
+        if isinstance(item, sa.ForeignKeyConstraint):
+            if _fk_signature(item) in deferred_fk_signatures:
+                continue
+        items.append(item)
+    return ops.CreateTableOp(
+        original_op.table_name,
+        items,
+        schema=original_op.schema,
+        if_not_exists=original_op.if_not_exists,
+        _namespace_metadata=original_op._namespace_metadata,
+        _constraints_included=original_op._constraints_included,
+        comment=original_op.comment,
+        info=dict(original_op.info),
+        prefixes=list(original_op.prefixes) if original_op.prefixes else None,
+        **dict(original_op.kw),
+    )
+
+
+def _build_dependency_graph(create_ops):
+    metadata = sa.MetaData()
+    create_ops_by_key = {
+        _table_key(create_op.schema, create_op.table_name): create_op
+        for create_op in create_ops
+    }
+    new_table_keys = set(create_ops_by_key)
+    dependencies = {key: set() for key in new_table_keys}
+    constraints_by_source = {key: [] for key in new_table_keys}
+
+    for source_key, create_op in create_ops_by_key.items():
+        table = create_op.to_table().to_metadata(metadata)
+        for constraint in table.foreign_key_constraints:
+            constraints_by_source[source_key].append(constraint)
+            target_key = _target_table_key(constraint)
+            if target_key in new_table_keys:
+                dependencies[source_key].add(target_key)
+
+    return create_ops_by_key, dependencies, constraints_by_source
+
+
+def _compute_strongly_connected_components(graph):
+    index = 0
+    indices = {}
+    lowlinks = {}
+    stack = []
+    on_stack = set()
+    components = []
+
+    def strongconnect(node):
+        nonlocal index
+        indices[node] = index
+        lowlinks[node] = index
+        index += 1
+        stack.append(node)
+        on_stack.add(node)
+
+        for neighbor in graph[node]:
+            if neighbor not in indices:
+                strongconnect(neighbor)
+                lowlinks[node] = min(lowlinks[node], lowlinks[neighbor])
+            elif neighbor in on_stack:
+                lowlinks[node] = min(lowlinks[node], indices[neighbor])
+
+        if lowlinks[node] == indices[node]:
+            component = []
+            while True:
+                member = stack.pop()
+                on_stack.remove(member)
+                component.append(member)
+                if member == node:
+                    break
+            components.append(component)
+
+    for node in graph:
+        if node not in indices:
+            strongconnect(node)
+
+    return components
+
+
+def _find_deferred_fk_signatures(dependencies, constraints_by_source):
+    components = _compute_strongly_connected_components(dependencies)
+    component_by_key = {}
+    cyclic_component_ids = set()
+
+    for index, component in enumerate(components):
+        for key in component:
+            component_by_key[key] = index
+        if len(component) > 1:
+            cyclic_component_ids.add(index)
+            continue
+        only_key = component[0]
+        if only_key in dependencies[only_key]:
+            cyclic_component_ids.add(index)
+
+    deferred_fk_signatures = set()
+    for source_key, constraints in constraints_by_source.items():
+        for constraint in constraints:
+            target_key = _target_table_key(constraint)
+            if target_key not in component_by_key:
+                continue
+            if component_by_key[source_key] != component_by_key[target_key]:
+                continue
+            if component_by_key[source_key] not in cyclic_component_ids:
+                continue
+            deferred_fk_signatures.add(_fk_signature(constraint))
+
+    return deferred_fk_signatures
+
+
+def _toposort_table_keys(original_keys, deferred_fk_signatures, constraints_by_source):
+    """
+    Topological sort of table keys, excluding deferred (cyclic) FKs.
+    
+    The dependency direction is: source_key depends ON target_key
+    So when we create tables, we should create target_key BEFORE source_key.
+    This means target_key has lower indegree (fewer tables it depends on).
+    """
+    # Build adjacency: dependencies[source] = {tables that source depends ON}
+    dependencies = {key: set() for key in original_keys}
+    
+    for source_key in original_keys:
+        for constraint in constraints_by_source[source_key]:
+            if _fk_signature(constraint) in deferred_fk_signatures:
+                continue
+            target_key = _target_table_key(constraint)
+            if target_key not in dependencies:
+                continue  # External table, skip
+            dependencies[source_key].add(target_key)
+    
+    # indegree[key] = number of tables that depend ON this key (should be created after this key)
+    # We want to process tables with indegree=0 first (no one depends on them to be created first)
+    # Actually for creation order: we need to create tables that ARE depended upon first
+    # So indegree here means "how many tables this table depends on"
+    indegree = {key: len(deps) for key, deps in dependencies.items()}
+    
+    # dependents[target] = {tables that depend ON target}
+    dependents = {key: set() for key in original_keys}
+    for source_key, target_keys in dependencies.items():
+        for target_key in target_keys:
+            dependents[target_key].add(source_key)
+    
+    # Start with tables that have no dependencies (can be created first)
+    ready = [key for key in original_keys if indegree[key] == 0]
+    ordered = []
+    visited = set()
+    
+    while ready:
+        key = ready.pop(0)
+        ordered.append(key)
+        visited.add(key)
+        
+        # For each table that depends on this key, reduce its indegree
+        for dependent_key in dependents[key]:
+            indegree[dependent_key] -= 1
+            if indegree[dependent_key] == 0 and dependent_key not in visited:
+                ready.append(dependent_key)
+    
+    # If we couldn't order all, return original order (shouldn't happen with proper SCC handling)
+    if len(ordered) != len(original_keys):
+        return list(original_keys)
+    return ordered
+
+
+def rewrite_create_table_dependency_order(container):
+    if container is None or not hasattr(container, "ops"):
+        return
+
+    create_ops = [op for op in container.ops if isinstance(op, ops.CreateTableOp)]
+    other_ops = [op for op in container.ops if not isinstance(op, ops.CreateTableOp)]
+    # 单表自引用外键也需要拆成后置 CreateForeignKeyOp，不能因「少于两张新表」而跳过
+    if not create_ops:
+        return
+
+    create_ops_by_key, dependencies, constraints_by_source = _build_dependency_graph(create_ops)
+    original_keys = [
+        _table_key(create_op.schema, create_op.table_name)
+        for create_op in create_ops
+    ]
+    deferred_fk_signatures = _find_deferred_fk_signatures(
+        dependencies,
+        constraints_by_source,
+    )
+    ordered_keys = _toposort_table_keys(
+        original_keys=original_keys,
+        deferred_fk_signatures=deferred_fk_signatures,
+        constraints_by_source=constraints_by_source,
+    )
+
+    rewritten_ops = [
+        _clone_create_table_op(create_ops_by_key[key], deferred_fk_signatures)
+        for key in ordered_keys
+    ]
+    deferred_fk_ops = [
+        ops.CreateForeignKeyOp.from_constraint(constraint)
+        for source_key in original_keys
+        for constraint in constraints_by_source[source_key]
+        if _fk_signature(constraint) in deferred_fk_signatures
+    ]
+
+    container.ops = rewritten_ops + deferred_fk_ops + other_ops