cg-code-graph 0.10.1__py3-none-any.whl

codegraph/plugins/django/schemas.py

@@ -0,0 +1,339 @@
+"""Wire schemas: django-ninja / pydantic Schema classes and DRF serializers -> field lists.
+
+Field dict: {name, json, type, nullable, required, read_only, write_only, many, ref (class qual of a nested
+schema), source, file, line, choices}. Stored on the class node as attrs.schema_fields so the cross-repo
+payload check can compare them with client JSON keys.
+"""
+from __future__ import annotations
+
+import ast
+import re
+
+from ..python.plugin import ClassInfo, Ctx, PyProgram, ann_base, ann_text, const_str, dotted, is_nullable_ann, kwarg
+
+PY_TYPES = {"str": "str", "int": "int", "float": "float", "bool": "bool", "dict": "dict", "Dict": "dict", "list": "list",
+            "List": "list", "datetime": "datetime", "date": "date", "time": "time", "UUID": "uuid", "Decimal": "decimal",
+            "Any": "any", "EmailStr": "str", "HttpUrl": "str", "AnyUrl": "str", "conint": "int", "constr": "str",
+            "confloat": "float", "Json": "json", "UploadedFile": "file", "bytes": "bytes", "timedelta": "duration",
+            "Literal": "str", "Enum": "str", "PositiveInt": "int", "NonNegativeInt": "int", "StrictStr": "str",
+            "StrictInt": "int", "StrictBool": "bool", "set": "list", "tuple": "list", "Sequence": "list", "object": "any"}
+DRF_TYPES = {"CharField": "str", "EmailField": "str", "RegexField": "str", "SlugField": "str", "URLField": "str",
+             "UUIDField": "uuid", "IPAddressField": "str", "IntegerField": "int", "FloatField": "float",
+             "DecimalField": "decimal", "BooleanField": "bool", "NullBooleanField": "bool", "DateTimeField": "datetime",
+             "DateField": "date", "TimeField": "time", "DurationField": "duration", "ChoiceField": "str",
+             "MultipleChoiceField": "list", "FileField": "file", "ImageField": "file", "ListField": "list",
+             "DictField": "dict", "HStoreField": "dict", "JSONField": "json", "ReadOnlyField": "any",
+             "HiddenField": "any", "SerializerMethodField": "any", "PrimaryKeyRelatedField": "int",
+             "HyperlinkedRelatedField": "str", "SlugRelatedField": "str", "StringRelatedField": "str",
+             "HyperlinkedIdentityField": "str", "ModelField": "any", "Field": "any", "ManyRelatedField": "list"}
+MODEL_TO_WIRE = {"fk": "int", "m2m": "list", "uuid": "str", "decimal": "str", "datetime": "datetime", "date": "date",
+                 "time": "str", "json": "json", "file": "str", "duration": "str"}
+
+
+def camel(s: str) -> str:
+    p = s.split("_")
+    return p[0] + "".join(x[:1].upper() + x[1:] for x in p[1:])
+
+
+class Schemas:
+    def __init__(self, prog: PyProgram, models):
+        self.prog = prog
+        self.models = models
+        self.cache: dict[str, list | None] = {}
+
+    def kind(self, c: ClassInfo) -> str | None:
+        p = self.prog
+        if p.subclass_of(c, "ninja.ModelSchema", "ninja.orm.metaclass.ModelSchema", "ninja.orm.ModelSchema"):
+            return "ninja_model"
+        if p.subclass_of(c, "ninja.Schema", "ninja.schema.Schema", "ninja.FilterSchema", "ninja.filter_schema.FilterSchema"):
+            return "ninja"
+        if p.subclass_of(c, "pydantic.BaseModel", "pydantic.main.BaseModel", "pydantic.v1.BaseModel"):
+            return "pydantic"
+        if p.subclass_of(c, "serializers.ModelSerializer", "serializers.HyperlinkedModelSerializer"):
+            return "drf_model"
+        if p.subclass_of(c, "serializers.Serializer", "serializers.BaseSerializer", "serializers.ListSerializer"):
+            return "drf"
+        return None
+
+    def fields(self, c: ClassInfo) -> list | None:
+        if c.qual in self.cache:
+            return self.cache[c.qual]
+        self.cache[c.qual] = []
+        k = self.kind(c)
+        out = None
+        if k in ("ninja", "pydantic", "ninja_model"):
+            out = self._pyd(c, k)
+        elif k in ("drf", "drf_model"):
+            out = self._drf(c, k)
+        self.cache[c.qual] = out
+        return out
+
+    # ---- pydantic / ninja
+    def _alias_gen(self, c: ClassInfo) -> str | None:
+        for k in [c] + [b[1] for b in self.prog.mro(c) if b[0] == "type"]:
+            cfg = k.attrs.get("model_config")
+            if cfg and isinstance(cfg[0], ast.Call):
+                ag = kwarg(cfg[0], "alias_generator")
+                if ag is not None:
+                    return (dotted(ag) or "").split(".")[-1]
+            for nm in ("Config", "Meta"):
+                inner = k.inner.get(nm)
+                if inner is None:
+                    continue
+                for st in inner.body:
+                    if isinstance(st, ast.Assign) and isinstance(st.targets[0], ast.Name) and st.targets[0].id == "alias_generator":
+                        return (dotted(st.value) or "").split(".")[-1]
+        return None
+
+    def _pyd(self, c: ClassInfo, kind: str) -> list:
+        prog = self.prog
+        chain = [c] + [b[1] for b in prog.mro(c) if b[0] == "type" and self.kind(b[1])]
+        fields: dict[str, dict] = {}
+        for k in reversed(chain):
+            if self.kind(k) == "ninja_model" or kind == "ninja_model":
+                for f in self._model_schema_fields(k):
+                    fields[f["name"]] = f
+            for name, (val, line, ann) in k.attrs.items():
+                if ann is None or name.startswith("_") or name in ("model_config", "Config", "Meta"):
+                    continue
+                if (dotted(ann) or "").endswith("ClassVar") or (isinstance(ann, ast.Subscript) and (dotted(ann.value) or "").endswith("ClassVar")):
+                    continue
+                fd = {"name": name, "json": name, "file": k.file, "line": line}
+                fd.update(self.ann_info(k, ann))
+                fd["nullable"] = fd.get("nullable") or is_nullable_ann(ann)
+                required = val is None
+                if isinstance(val, ast.Call) and (dotted(val.func) or "").split(".")[-1] in ("Field", "Query", "Body", "Form", "Path", "File"):
+                    d0 = val.args[0] if val.args else kwarg(val, "default")
+                    required = d0 is None and kwarg(val, "default_factory") is None or (isinstance(d0, ast.Constant) and d0.value is Ellipsis)
+                    al = const_str(kwarg(val, "alias")) or const_str(kwarg(val, "serialization_alias"))
+                    if al:
+                        fd["alias"] = al
+                    if isinstance(d0, ast.Constant) and d0.value is None:
+                        fd["default_none"] = True
+                elif isinstance(val, ast.Constant) and val.value is None:
+                    fd["default_none"] = True
+                fd["required"] = bool(required)
+                fields[name] = fd
+            for name, f in k.methods.items():
+                if name.startswith("resolve_") and name[8:] in fields:
+                    fields[name[8:]]["resolver"] = f"{f.file}:{f.line}"
+        ag = self._alias_gen(c)
+        for fd in fields.values():
+            if ag and "camel" in ag.lower():
+                fd["json_in"] = camel(fd["name"])
+                if kind == "pydantic":
+                    fd["json"] = camel(fd["name"])
+            if kind == "pydantic" and fd.get("alias"):
+                fd["json"] = fd["alias"]
+        return list(fields.values())
+
+    def ann_info(self, k: ClassInfo, ann) -> dict:
+        e, cont = ann_base(ann)
+        out = {"type_text": ann_text(ann)}
+        if cont == "list":
+            out["many"] = True
+        if e is None:
+            out["type"] = "list" if cont == "list" else ("dict" if "Dict" in (ann_text(ann) or "") or "dict" in (ann_text(ann) or "") else "any")
+            return out
+        if isinstance(e, ast.Subscript):
+            head = (dotted(e.value) or "").split(".")[-1]
+            if head == "Literal":
+                sl = e.slice
+                vals = [x.value for x in (sl.elts if isinstance(sl, ast.Tuple) else [sl]) if isinstance(x, ast.Constant)]
+                out["choices"] = vals
+                out["type"] = "str" if all(isinstance(v, str) for v in vals) else "any"
+                return out
+            out["type"] = PY_TYPES.get(head, "any")
+            return out
+        d = dotted(e)
+        t = self.prog.infer(e, Ctx(k.module, None, None))
+        if t and t[0] == "type":
+            if self.kind(t[1]):
+                out["ref"] = t[1].qual
+                out["type"] = "object"
+                return out
+            if self.prog.subclass_of(t[1], "Enum", "TextChoices", "IntegerChoices", "StrEnum", "IntEnum", "Choices"):
+                out["type"] = "int" if self.prog.subclass_of(t[1], "IntegerChoices", "IntEnum") else "str"
+                out["choices"] = self.models.enum_values(t[1]) if self.models else None
+                out["enum"] = t[1].qual
+                return out
+        last = (d or "").split(".")[-1]
+        out["type"] = PY_TYPES.get(last, "any")
+        return out
+
+    def str_list(self, m, e, depth=0):
+        """Literal list/tuple of strings, possibly via a module var or `a + b` concatenation; else None."""
+        if depth > 5 or e is None:
+            return None
+        if isinstance(e, (ast.List, ast.Tuple, ast.Set)):
+            vals = [const_str(x) for x in e.elts]
+            return [v for v in vals if v is not None]
+        if isinstance(e, ast.Constant) and e.value == "__all__":
+            return "__all__"
+        if isinstance(e, ast.BinOp) and isinstance(e.op, ast.Add):
+            a, b = self.str_list(m, e.left, depth + 1), self.str_list(m, e.right, depth + 1)
+            if isinstance(a, list) and isinstance(b, list):
+                return a + b
+            return None
+        if isinstance(e, (ast.Name, ast.Attribute)):
+            t = self.prog.infer(e, Ctx(m, None, None))
+            if t and t[0] == "var":
+                return self.str_list(t[1], self.prog.var_value(t[1], t[2]), depth + 1)
+        return None
+
+    def _meta_opts(self, c: ClassInfo) -> dict:
+        out = {}
+        for nm in ("Meta", "Config"):
+            inner = c.inner.get(nm)
+            if inner is None:
+                continue
+            for st in inner.body:
+                if isinstance(st, ast.Assign) and isinstance(st.targets[0], ast.Name):
+                    key = st.targets[0].id
+                    v = st.value
+                    if isinstance(v, ast.Constant):
+                        out[key] = v.value
+                    elif isinstance(v, ast.Dict):
+                        out[key] = v
+                    elif key in ("fields", "exclude", "read_only_fields", "model_fields", "model_exclude", "fields_optional",
+                                 "model_fields_optional", "brief_fields"):
+                        sl = self.str_list(c.module, v)
+                        if sl is not None:
+                            out[key] = sl
+                        else:
+                            out[key + "_unresolved"] = ann_text(v)
+                    else:
+                        out[key] = v
+        return out
+
+    def _model_of(self, c: ClassInfo, opts: dict):
+        m = opts.get("model")
+        if isinstance(m, ast.AST):
+            t = self.prog.infer(m, Ctx(c.module, None, None))
+            if t and t[0] == "type" and self.models and t[1].qual in self.models.models:
+                return t[1].qual
+        return None
+
+    def _model_schema_fields(self, c: ClassInfo) -> list:
+        opts = self._meta_opts(c)
+        mq = self._model_of(c, opts)
+        if not mq:
+            return []
+        mf = self.models.models[mq]["fields"]
+        sel = opts.get("fields") if opts.get("fields") is not None else opts.get("model_fields")
+        exclude = opts.get("exclude") or opts.get("model_exclude") or []
+        exclude = set(exclude) if isinstance(exclude, list) else set()
+        names = list(mf) if not isinstance(sel, list) else [x for x in sel if x in mf]
+        opt = opts.get("fields_optional") or opts.get("model_fields_optional")
+        out = []
+        for n in names:
+            if n in exclude or mf[n].get("virtual") or mf[n]["type"] == "m2m_rev":
+                continue
+            fd = mf[n]
+            t = MODEL_TO_WIRE.get(fd["type"], fd["type"])
+            out.append({"name": n, "json": n, "type": t, "nullable": bool(fd.get("null")), "required": not (fd.get("null") or fd.get("has_default") or fd.get("blank") or fd.get("auto") or opt == "__all__" or (isinstance(opt, list) and n in opt)),
+                        "file": fd["file"], "line": fd["line"], "from_model": mq, **({"choices": fd["choices"]} if fd.get("choices") else {})})
+        return out
+
+    # ---- DRF
+    def _drf(self, c: ClassInfo, kind: str) -> list:
+        prog = self.prog
+        chain = [c] + [b[1] for b in prog.mro(c) if b[0] == "type" and self.kind(b[1])]
+        fields: dict[str, dict] = {}
+        opts = {}
+        for k in reversed(chain):
+            o = self._meta_opts(k)
+            if o:
+                opts = {**opts, **o}
+        mq = self._model_of(c, opts) or next((self._model_of(k, self._meta_opts(k)) for k in chain if self._meta_opts(k)), None)
+        if kind == "drf_model" and mq:
+            mf = self.models.models[mq]["fields"]
+            sel = opts.get("fields")
+            exclude = set(opts.get("exclude")) if isinstance(opts.get("exclude"), list) else set()
+            names = [n for n in mf if not mf[n].get("virtual") and mf[n]["type"] != "m2m_rev"] if sel in ("__all__", None) else list(sel)
+            ro = set(opts.get("read_only_fields") or []) if isinstance(opts.get("read_only_fields"), list) else set()
+            if not (sel in ("__all__", None) or isinstance(sel, list)):
+                sel = None
+            xk = {}
+            if isinstance(opts.get("extra_kwargs"), ast.Dict):
+                for kk, vv in zip(opts["extra_kwargs"].keys, opts["extra_kwargs"].values):
+                    s = const_str(kk)
+                    if s and isinstance(vv, ast.Dict):
+                        xk[s] = {const_str(a): (b.value if isinstance(b, ast.Constant) else None) for a, b in zip(vv.keys, vv.values)}
+            for n in names:
+                if n in exclude:
+                    continue
+                fd = mf.get(n)
+                if fd is None:
+                    fields[n] = {"name": n, "json": n, "type": "any", "file": c.file, "line": c.line, "unresolved": True,
+                                 "required": False, "read_only": True}
+                    continue
+                t = MODEL_TO_WIRE.get(fd["type"], fd["type"])
+                f2 = {"name": n, "json": n, "type": t, "nullable": bool(fd.get("null")), "file": fd["file"], "line": fd["line"],
+                      "from_model": mq, "read_only": n in ro or bool(fd.get("auto")) or fd.get("editable") is False,
+                      "required": not (fd.get("null") or fd.get("blank") or fd.get("has_default") or fd.get("auto"))}
+                if fd.get("choices"):
+                    f2["choices"] = fd["choices"]
+                e = xk.get(n) or {}
+                for kk in ("read_only", "write_only", "required", "allow_null"):
+                    if kk in e and e[kk] is not None:
+                        f2["nullable" if kk == "allow_null" else kk] = e[kk]
+                fields[n] = f2
+        for k in reversed(chain):
+            for name, (val, line, ann) in k.attrs.items():
+                if not isinstance(val, ast.Call) or name in ("Meta",):
+                    continue
+                t = prog.infer(val.func, Ctx(k.module, None, None))
+                fcls = None
+                ref = None
+                if t and t[0] == "ext":
+                    fcls = t[1].split(".")[-1]
+                    if fcls not in DRF_TYPES and not fcls.endswith("Field") and not fcls.endswith("Serializer"):
+                        continue
+                elif t and t[0] == "type":
+                    if self.kind(t[1]) in ("drf", "drf_model"):
+                        ref = t[1].qual
+                        fcls = "Serializer"
+                    elif prog.subclass_of(t[1], "Field", "RelatedField", "serializers.Field"):
+                        fcls = next((b.split(".")[-1] for b in prog.ext_bases(t[1]) if b.split(".")[-1] in DRF_TYPES), "Field")
+                    else:
+                        continue
+                else:
+                    continue
+                kw = {x.arg: (x.value.value if isinstance(x.value, ast.Constant) else x.value) for x in val.keywords if x.arg}
+                fd = {"name": name, "json": name, "file": k.file, "line": line, "field_class": fcls,
+                      "type": "object" if ref else DRF_TYPES.get(fcls, "any"),
+                      "read_only": kw.get("read_only") is True or fcls in ("SerializerMethodField", "ReadOnlyField", "HyperlinkedIdentityField", "StringRelatedField"),
+                      "write_only": kw.get("write_only") is True,
+                      "nullable": kw.get("allow_null") is True}
+                fd["required"] = (kw.get("required") is not False) and not fd["read_only"] and "default" not in kw
+                if ref:
+                    fd["ref"] = ref
+                if kw.get("many") is True or fcls in ("ListField", "ManyRelatedField", "MultipleChoiceField"):
+                    fd["many"] = True
+                src = kw.get("source")
+                if isinstance(src, str):
+                    fd["source"] = src
+                    if mq and src.split(".")[0] in self.models.models[mq]["fields"]:
+                        mfd = self.models.models[mq]["fields"][src.split(".")[0]]
+                        if "." not in src:
+                            fd["nullable"] = fd["nullable"] or bool(mfd.get("null"))
+                elif mq and name in self.models.models[mq]["fields"] and fd["type"] in ("any",):
+                    mfd = self.models.models[mq]["fields"][name]
+                    fd["type"] = MODEL_TO_WIRE.get(mfd["type"], mfd["type"])
+                ch = kw.get("choices")
+                if isinstance(ch, ast.AST) and self.models:
+                    vals = self.models.choices(k, ch)
+                    if vals:
+                        fd["choices"] = vals
+                fields[name] = fd
+        return list(fields.values())
+
+    def describe(self, qual: str) -> dict | None:
+        c = self.prog.classes.get(qual)
+        if c is None:
+            return None
+        fs = self.fields(c)
+        if fs is None:
+            return None
+        return {"class": qual, "kind": self.kind(c), "fields": fs, "file": c.file, "line": c.line}

codegraph/plugins/django/shapes.py

@@ -0,0 +1,216 @@
+"""Nested JSON shapes of values a Django/ninja view returns (dict literals, helper functions building
+dicts, Schema.from_orm(...).dict(), list comprehensions), with value types inferred from model
+fields (`obj.title` -> CharField -> str, null=True -> nullable) and literals.
+
+shape = {key: {"line", "file", "type", "nullable", "many", "children": shape | None, "schema": qual | None}}
+"""
+from __future__ import annotations
+
+import ast
+
+from ..python.plugin import Ctx, FuncInfo, const_str, dotted
+
+PY_CASTS = {"str": "str", "int": "int", "float": "float", "bool": "bool", "len": "int", "round": "float", "sum": "int",
+            "Decimal": "decimal", "list": "list", "dict": "dict", "sorted": "list"}
+STR_METHODS = {"isoformat", "strftime", "lower", "upper", "strip", "format", "join", "replace", "get_full_name", "__str__",
+               "get_absolute_url", "build_absolute_uri", "hex"}
+
+
+class ShapeBuilder:
+    def __init__(self, plugin):
+        self.p = plugin
+        self.prog = plugin.prog
+        self.models = plugin.models
+
+    def returns(self, f: FuncInfo, depth=0) -> list[tuple[ast.AST, int | None]]:
+        out = []
+        for sub in ast.walk(f.node):
+            if isinstance(sub, ast.Return) and sub.value is not None:
+                v, status = sub.value, None
+                if isinstance(v, ast.Tuple) and len(v.elts) == 2 and isinstance(v.elts[0], ast.Constant):
+                    status, v = v.elts[0].value, v.elts[1]
+                out.append((v, status, sub.lineno))
+        return out
+
+    def shape(self, e, ctx: Ctx, env=None, depth=0) -> dict | None:
+        env = env or {}
+        if depth > 5 or e is None:
+            return None
+        if isinstance(e, ast.Dict):
+            out = {}
+            for k, v in zip(e.keys, e.values):
+                if k is None:  # **spread
+                    sub = self.shape(v, ctx, env, depth + 1)
+                    if sub:
+                        out.update(sub)
+                    continue
+                name = const_str(k)
+                if name is None:
+                    continue
+                out[name] = dict(self.value(v, ctx, env, depth + 1), line=v.lineno, file=ctx.mod.file)
+            return out
+        if isinstance(e, ast.Call):
+            fn = (dotted(e.func) or "").split(".")[-1]
+            if fn == "dict" and e.keywords:
+                return {k.arg: dict(self.value(k.value, ctx, env, depth + 1), line=k.value.lineno, file=ctx.mod.file)
+                        for k in e.keywords if k.arg}
+            if fn in ("JsonResponse", "Response", "JSONResponse", "HttpResponse") and e.args:
+                return self.shape(e.args[0], ctx, env, depth + 1)
+            if isinstance(e.func, ast.Attribute) and e.func.attr in ("dict", "model_dump") and isinstance(e.func.value, ast.Call):
+                return self.schema_shape(e.func.value, ctx)
+            sc = self.schema_shape(e, ctx)
+            if sc is not None:
+                return sc
+            t = self.prog.infer(e.func, ctx)
+            if t and t[0] in ("func", "bound") and depth < 4:
+                f = t[1]
+                c2 = Ctx(f.module, f, f.cls)
+                merged: dict = {}
+                for v, status, line in self.returns(f):
+                    s = self.shape(v, c2, {}, depth + 1)
+                    if s:
+                        for k, info in s.items():
+                            merged.setdefault(k, info)
+                return merged or None
+            return None
+        if isinstance(e, ast.Name) and ctx.func is not None:
+            if e.id in env:
+                return None
+            out = {}
+            for val, ann, kind in self.prog.local_vars(ctx).get(e.id, []):
+                if val is not None and not isinstance(val, ast.Name):
+                    s = self.shape(val, ctx, env, depth + 1)
+                    if s:
+                        out.update(s)
+            for sub in ast.walk(ctx.func.node):  # d["k"] = v
+                if isinstance(sub, ast.Assign):
+                    for t in sub.targets:
+                        if isinstance(t, ast.Subscript) and isinstance(t.value, ast.Name) and t.value.id == e.id and const_str(t.slice):
+                            out.setdefault(const_str(t.slice), dict(self.value(sub.value, ctx, env, depth + 1), line=sub.lineno,
+                                                                    file=ctx.mod.file, conditional=True))
+            return out or None
+        return None
+
+    def schema_shape(self, call: ast.Call, ctx: Ctx) -> dict | None:
+        """Schema.from_orm(x) / Schema.model_validate(x) / Schema(**kw) / Serializer(x).data -> declared fields."""
+        f = call.func
+        tgt = f.value if isinstance(f, ast.Attribute) and f.attr in ("from_orm", "model_validate", "from_attributes", "validate") else f
+        t = self.prog.infer(tgt, ctx)
+        if t and t[0] == "type" and self.p.schemas.kind(t[1]):
+            return self.fields_shape(t[1].qual)
+        return None
+
+    def fields_shape(self, qual: str, depth=0) -> dict:
+        c = self.prog.classes.get(qual)
+        out = {}
+        for fd in (self.p.schemas.fields(c) if c else []) or []:
+            ch = self.fields_shape(fd["ref"], depth + 1) if fd.get("ref") and depth < 4 else None
+            out[fd.get("json") or fd["name"]] = {"type": fd.get("type"), "nullable": fd.get("nullable"), "many": fd.get("many"),
+                                                 "children": ch, "schema": qual, "line": fd.get("line"), "file": fd.get("file"),
+                                                 "choices": fd.get("choices")}
+        return out
+
+    def value(self, v, ctx: Ctx, env, depth) -> dict:
+        if isinstance(v, ast.Constant):
+            if v.value is None:
+                return {"type": "null", "nullable": True}
+            return {"type": {str: "str", int: "int", float: "float", bool: "bool"}.get(type(v.value), "any")}
+        if isinstance(v, ast.JoinedStr):
+            return {"type": "str"}
+        if isinstance(v, (ast.Dict,)) or (isinstance(v, ast.Call) and (dotted(v.func) or "").split(".")[-1] == "dict"):
+            return {"type": "dict", "children": self.shape(v, ctx, env, depth + 1)}
+        if isinstance(v, (ast.List, ast.Tuple)):
+            el = v.elts[0] if v.elts else None
+            info = self.value(el, ctx, env, depth + 1) if el is not None else {}
+            return {"type": "list", "many": True, "children": info.get("children"), "item_type": info.get("type")}
+        if isinstance(v, ast.ListComp):
+            env2 = dict(env)
+            g = v.generators[0]
+            if isinstance(g.target, ast.Name):
+                it = self.prog.infer(g.iter, ctx)
+                env2[g.target.id] = self.prog.iter_type(it) or (it[1] if it and it[0] == "list" else None)
+            info = self.value(v.elt, ctx, env2, depth + 1)
+            return {"type": "list", "many": True, "children": info.get("children"), "item_type": info.get("type")}
+        if isinstance(v, ast.IfExp):
+            a = self.value(v.body, ctx, env, depth + 1)
+            b = self.value(v.orelse, ctx, env, depth + 1)
+            base = a if a.get("type") not in (None, "null") else (b if b.get("type") not in (None, "null") else dict(a, type=None))
+            return dict(base, nullable=bool(a.get("nullable") or b.get("nullable") or a.get("type") == "null" or b.get("type") == "null"))
+        if isinstance(v, ast.BoolOp):
+            return self.value(v.values[-1], ctx, env, depth + 1) if isinstance(v.op, ast.Or) else {"type": "any"}
+        if isinstance(v, ast.Compare) or (isinstance(v, ast.UnaryOp) and isinstance(v.op, ast.Not)):
+            return {"type": "bool"}
+        if isinstance(v, ast.BinOp):
+            l, r = self.value(v.left, ctx, env, depth + 1), self.value(v.right, ctx, env, depth + 1)
+            if "str" in (l.get("type"), r.get("type")):
+                return {"type": "str"}
+            if l.get("type") in ("int", "float") and r.get("type") in ("int", "float"):
+                return {"type": "float" if "float" in (l.get("type"), r.get("type")) or isinstance(v.op, ast.Div) else "int"}
+            return {"type": None}
+        if isinstance(v, ast.Call):
+            fn = dotted(v.func) or ""
+            last = fn.split(".")[-1]
+            if last in PY_CASTS and "." not in fn:
+                return {"type": PY_CASTS[last]}
+            if isinstance(v.func, ast.Attribute) and v.func.attr in STR_METHODS:
+                inner = self.value(v.func.value, ctx, env, depth + 1)
+                return {"type": "str", "nullable": False}
+            if isinstance(v.func, ast.Attribute) and v.func.attr in ("count",):
+                return {"type": "int"}
+            if isinstance(v.func, ast.Attribute) and v.func.attr in ("dict", "model_dump") and isinstance(v.func.value, ast.Call):
+                return {"type": "dict", "children": self.schema_shape(v.func.value, ctx)}
+            s = self.shape(v, ctx, env, depth + 1)
+            if s:
+                return {"type": "dict", "children": s}
+            t = self.prog.infer(v.func, ctx)
+            if t and t[0] in ("func", "bound"):
+                f = t[1]
+                rets = self.returns(f)
+                if rets:
+                    vv = rets[0][0]
+                    if isinstance(vv, (ast.List, ast.ListComp)):
+                        return self.value(vv, Ctx(f.module, f, f.cls), {}, depth + 1)
+            return {"type": None}
+        if isinstance(v, ast.Attribute):
+            return self.attr_value(v, ctx, env, depth)
+        if isinstance(v, ast.Name):
+            if v.id in env:
+                return {"type": "model", "model": env[v.id][1].qual} if env[v.id] and env[v.id][0] == "inst" else {"type": None}
+            vals = [val for val, ann, kind in self.prog.local_vars(ctx).get(v.id, []) if val is not None] if ctx.func else []
+            if ctx.func and any(isinstance(x, ast.List) and not x.elts for x in vals):
+                for sub in ast.walk(ctx.func.node):  # items = []; items.append({...})
+                    if isinstance(sub, ast.Call) and isinstance(sub.func, ast.Attribute) and sub.func.attr == "append" \
+                            and isinstance(sub.func.value, ast.Name) and sub.func.value.id == v.id and sub.args:
+                        info = self.value(sub.args[0], ctx, {**env, v.id: None}, depth + 1)
+                        return {"type": "list", "many": True, "children": info.get("children"), "item_type": info.get("type")}
+            if len(vals) >= 1 and depth < 4:
+                infos = [self.value(x, ctx, {**env, v.id: None}, depth + 1) for x in vals[:3]]
+                base = next((i for i in infos if i.get("type") not in (None, "null")), infos[0])
+                return dict(base, nullable=any(i.get("nullable") or i.get("type") == "null" for i in infos) or base.get("nullable"))
+            return {"type": None}
+        if isinstance(v, ast.Subscript):
+            return {"type": None}
+        return {"type": None}
+
+    def attr_value(self, v: ast.Attribute, ctx: Ctx, env, depth) -> dict:
+        base = v.value
+        if isinstance(base, ast.Name) and base.id in env and env[base.id] and env[base.id][0] == "inst":
+            t = env[base.id]
+        else:
+            t = self.prog.infer(base, ctx)
+        if isinstance(base, ast.Attribute) and v.attr in ("url", "name", "path"):
+            inner = self.attr_value(base, ctx, env, depth + 1)
+            if inner.get("type") == "file":
+                return {"type": "str", "nullable": inner.get("nullable"), "model_field": inner.get("model_field")}
+        if t and t[0] == "inst":
+            mf = self.models.field(t[1].qual, v.attr)
+            if mf:
+                nullable = bool(mf.get("null")) or (mf.get("type") == "file" and bool(mf.get("blank")))
+                typ = mf.get("type")
+                if typ == "fk":
+                    typ = "model"
+                return {"type": typ, "nullable": nullable, "model_field": f"{t[1].qual}.{v.attr}", "choices": mf.get("choices"),
+                        "field_line": mf.get("line"), "field_file": mf.get("file")}
+            if v.attr == "id" or v.attr == "pk":
+                return {"type": "int"}
+        return {"type": None}