diff --git a/.gitignore b/.gitignore index accdaa3..9057eff 100644 --- a/.gitignore +++ b/.gitignore @@ -179,3 +179,9 @@ cython_debug/ # PyPI configuration file .pypirc +# Ignore all dotfiles/dotfolders in the home dir (credentials, tool state, etc.) +.* + +# rsts sind nur ein zwischenschritt für Testdaten. 1. reproduzierbar, 2. nur kurzfristig nötig +rsts/ + diff --git a/README.md b/README.md index 6a25462..caa5a2a 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,24 @@ # Datenbankmigration von 5.0 auf 8.0 -aktuell zwei Ansätze: -- Codeanalyse des Updatemechanismus -- Unterschiede im Zustand erkennen nachdem in beiden Versionen die gleichen Testdaten angelegt wurden. +Ziel: verstehen, wie sich das Datenbankschema der aktiven Tryton-Module +über die Versionen 5.0 bis 8.0 verändert, als Vorbereitung für die +eigentliche Migration. Zwei sich ergänzende Ansätze: +- **[doc/UPDATEANALYSE.md](doc/UPDATEANALYSE.md)** – Codeanalyse des + Updatemechanismus: statischer Scan der `__register__`-Methoden aller + Module über alle Versions-Branches hinweg. _(fertig)_ +- **[doc/TESTDATEN.md](doc/TESTDATEN.md)** – Unterschiede im Zustand + erkennen, nachdem in zwei frisch installierten Versionen dieselben + Testdaten per Proteus angelegt wurden (Snapshot- und später + SQL-Dump-Vergleich). _(in Arbeit - siehe Stand im Dokument)_ + - dazu als Vorarbeit: **[doc/MODELLVERGLEICH.md](doc/MODELLVERGLEICH.md)** + – welche Modelle/Felder gibt es je Version überhaupt, und wo hat sich + zwischen 5.0 und 8.0 tatsächlich etwas geändert (steuert, wo sich + Testdaten-Aufwand lohnt). + +Eigene, von den Standardmodulen abweichende Module (`production`, +`stock_product_location`, `stock_split`, `stock_lot_sequence`) sind +bewusst noch nicht Teil dieser Analyse - erst wenn die Standardmodule +migrierbar sind, werden diese auf 8.0 portiert und die Testdaten-Pipeline +darauf erweitert. diff --git a/compare_snapshots.py b/compare_snapshots.py new file mode 100644 index 0000000..a5c72f8 --- /dev/null +++ b/compare_snapshots.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +""" +compare_snapshots.py + +Vergleicht zwei mit create_dataset.py erzeugte Snapshots (z. B. aus +Version 6.8 und 7.0, jeweils mit derselben dataset.yaml erzeugt) und +markiert: + + - status_changed: Datensatz ist in einer Version fehlgeschlagen, in der + anderen nicht -> Kandidat für Format-/ + Constraint-/Pflichtfeld-Änderung + - value_changed: gespeicherter Wert unterscheidet sich zwischen den + Versionen, obwohl derselbe Eingabewert verwendet + wurde -> Kandidat für automatische Reformatierung + - missing_record: Datensatz-Key nur in einem der beiden Snapshots + vorhanden (z. B. weil er in dataset.yaml erst später + ergänzt wurde) + +Nutzung: + python3 compare_snapshots.py snapshot_68.json snapshot_70.json \\ + --label-a 6.8 --label-b 7.0 + +Weiter geht's dann typischerweise so: Modellname aus einem Fund hier +nehmen, den zugehörigen Tabellennamen bilden (Punkte durch Unterstriche +ersetzen, wie es extract_updates.py auch tut) und in den AST-Analyse-Ergebnissen +danach filtern: + + jq '.files[].operations[] | select(.tables[]? == "party_identifier")' \\ + data/7.0/party.json +""" + +import argparse +import json + + +def load(path): + return json.load(open(path, encoding="utf-8")) + + +def index_by_key(snapshot): + return {r["key"]: r for r in snapshot["results"]} + + +def compare(snap_a, snap_b, label_a, label_b): + a = index_by_key(snap_a) + b = index_by_key(snap_b) + + findings = [] + + for key in sorted(set(a) | set(b)): + ra, rb = a.get(key), b.get(key) + + if ra is None or rb is None: + findings.append({ + "key": key, + "kind": "missing_record", + "detail": f"nur in {label_b if ra is None else label_a} vorhanden", + }) + continue + + if ra["status"] != rb["status"]: + findings.append({ + "key": key, + "model": ra["model"], + "kind": "status_changed", + "detail": ( + f"{label_a}: {ra['status']} ({ra.get('error')}) | " + f"{label_b}: {rb['status']} ({rb.get('error')})" + ), + }) + continue + + if ra["status"] == "error": + continue # beide fehlgeschlagen - nichts auf Feldebene zu vergleichen + + fields_a, fields_b = ra["stored"], rb["stored"] + for field in sorted(set(fields_a) | set(fields_b)): + va = fields_a.get(field, "") + vb = fields_b.get(field, "") + if va != vb: + findings.append({ + "key": key, + "model": ra["model"], + "field": field, + "kind": "value_changed", + "detail": f"{label_a}={va!r} | {label_b}={vb!r}", + }) + + return findings + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("snapshot_a") + parser.add_argument("snapshot_b") + parser.add_argument("--label-a", default="A") + parser.add_argument("--label-b", default="B") + args = parser.parse_args() + + findings = compare( + load(args.snapshot_a), load(args.snapshot_b), args.label_a, args.label_b + ) + + if not findings: + print("Keine Unterschiede gefunden.") + return + + by_model = {} + for f in findings: + by_model.setdefault(f.get("model", "(kein Modell)"), []).append(f) + + for model, items in sorted(by_model.items()): + if model == "(kein Modell)": + print(f"\n=== {model} - {len(items)} Fund(e) ===") + else: + table = model.replace(".", "_") + print(f"\n=== {model} (Tabelle vermutlich: {table}) - {len(items)} Fund(e) ===") + for item in items: + field_suffix = f".{item['field']}" if "field" in item else "" + print(f" [{item['kind']}] {item['key']}{field_suffix}: {item['detail']}") + + +if __name__ == "__main__": + main() diff --git a/compare.py b/compare_updates.py similarity index 99% rename from compare.py rename to compare_updates.py index 798440e..78be03a 100644 --- a/compare.py +++ b/compare_updates.py @@ -6,7 +6,7 @@ from collections import OrderedDict DATA = Path("data") -REPORTS = Path("reports") +REPORTS = Path("reports/updateChanges") VERSION_DIRS = sorted( [d for d in DATA.iterdir() if d.is_dir()], diff --git a/create_dataset.py b/create_dataset.py new file mode 100644 index 0000000..3c4dc45 --- /dev/null +++ b/create_dataset.py @@ -0,0 +1,281 @@ +#!/usr/bin/env python3 +""" +create_dataset.py + +Legt über Proteus einen deklarativ definierten, reproduzierbaren +Testdatensatz an und liest ihn danach FRISCH VOM SERVER zurück (nicht aus +dem lokalen Proteus-Cache) - damit automatische Reformatierung durch die +Zielversion sichtbar wird. Ergebnis wird als JSON-Snapshot gespeichert. + +Gedacht, um dieselbe dataset.yaml gegen zwei Tryton-Versionen laufen zu +lassen (zwei getrennte, frisch installierte Datenbanken) und die beiden +Snapshots danach mit compare_snapshots.py zu vergleichen. + +Nutzung: + python3 create_dataset.py --config dataset.yaml \\ + --database mydb_68 --output snapshot_68.json + + python3 create_dataset.py --config dataset.yaml \\ + --database mydb_70 --output snapshot_70.json + + python3 compare_snapshots.py snapshot_68.json snapshot_70.json \\ + --label-a 6.8 --label-b 7.0 + +WICHTIG: Dieses Skript wurde nicht gegen einen echten Tryton-Server +getestet (dafür fehlt hier die Umgebung) - nur auf Syntax geprüft. Bitte +bei dir gegenlesen, insbesondere proteus_config.set_trytond(...) an eure +tatsächliche Verbindungsart anpassen (lokal via Unix-Socket/Config-Datei +oder per XML-RPC/JSON-RPC über Netzwerk - die Proteus-API unterscheidet +sich da je nach Version leicht). + +Feld-Umbenennungen (FIELD_RENAMES): +Da dieselbe dataset.yaml gegen mehrere Versionen laufen soll, aber Felder +zwischen Versionen umbenannt werden können (bestätigt: stock.move.uom -> +stock.move.unit zwischen 5.0 und 8.0), wird pro Modell zuerst geprüft, ob +der im YAML angegebene Feldname auf dem jeweiligen Server tatsächlich +existiert (via fields_get()). Falls nicht, aber ein bekannter Alias aus +FIELD_RENAMES existiert UND der Alias-Name dort existiert, wird der Alias +verwendet - der Datensatz landet dann inhaltlich identisch in beiden +Datenbanken, nur eben unter dem jeweils richtigen Feldnamen. Im +JSON-Snapshot ("stored") wird trotzdem immer der ORIGINALE YAML-Feldname +als Key verwendet, damit compare_snapshots.py die Werte über beide +Versionen hinweg unter demselben Key vergleicht. + +Ein wirklich unbekanntes Feld (kein Treffer in FIELD_RENAMES, oder Alias +existiert dort ebenfalls nicht) wird NICHT stillschweigend übergangen, +sondern lässt den Record ganz normal mit AttributeError fehlschlagen - +das ist ja gerade das gesuchte Signal für eine echte Schema-Änderung. +""" + +import argparse +import decimal +import datetime +import json +import sys +import traceback +from pathlib import Path + +try: + import yaml +except ImportError: + yaml = None + +from proteus import Model, config as proteus_config + + +# Bekannte Feld-Umbenennungen zwischen Tryton-Versionen: Modell -> {einer +# der beiden Feldnamen: der jeweils andere}. Nur eine Richtung eintragen +# (z. B. die 5.0->8.0-Richtung) - _bidirectional_field_renames() ergänzt +# die Rückrichtung automatisch, damit die Auflösung unabhängig davon +# funktioniert, mit welcher Version die dataset.yaml ursprünglich gebaut +# wurde. Bei Bedarf ergänzen, sobald ein compare_snapshots.py-Lauf einen +# weiteren Fall aufdeckt. +FIELD_RENAMES = { + "stock.move": {"uom": "unit"}, +} + + +def _bidirectional_field_renames(field_renames): + result = {} + for model_name, renames in field_renames.items(): + both = dict(renames) + both.update({new: old for old, new in renames.items()}) + result[model_name] = both + return result + + +BIDIRECTIONAL_FIELD_RENAMES = _bidirectional_field_renames(FIELD_RENAMES) + + +def resolve_field_name(RecordModel, model_name, field_name, fields_cache): + """Liefert den auf DIESEM Server tatsächlich existierenden Feldnamen. + + Existiert field_name direkt (fields_get()), wird er unverändert + zurückgegeben. Sonst wird in FIELD_RENAMES nachgeschaut (in beide + Richtungen), ob ein bekannter Alias existiert UND auf diesem Server + tatsächlich vorhanden ist. Andernfalls bleibt field_name unverändert, + damit ein wirklich unbekanntes Feld weiterhin als Fehler auffällt. + """ + if model_name not in fields_cache: + try: + fields_cache[model_name] = set(RecordModel.fields_get().keys()) + except Exception: + fields_cache[model_name] = None # unbekannt - keine Alias-Auflösung möglich + + available = fields_cache[model_name] + if available is None or field_name in available: + return field_name + + alias = BIDIRECTIONAL_FIELD_RENAMES.get(model_name, {}).get(field_name) + if alias and alias in available: + return alias + return field_name + + +def load_spec(path): + text = Path(path).read_text(encoding="utf-8") + if path.endswith((".yaml", ".yml")): + if yaml is None: + raise RuntimeError( + "PyYAML nicht installiert (pip install pyyaml) - " + "oder --config auf eine .json-Datei zeigen lassen." + ) + return yaml.safe_load(text) + return json.loads(text) + + +def resolve_value(value, created): + """ + Löst Referenzen der Form {"$ref": "irgendein_key"} auf bereits in + diesem Lauf erzeugte Datensätze auf (z. B. um eine Adresse mit der + vorher angelegten Party zu verknüpfen). Referenzen können nur auf + Records verweisen, die im YAML VOR der aktuellen Stelle stehen. + + Versteht außerdem die von rst_to_dataset.py erzeugten Marker für + Werte, die kein einfacher JSON-Typ sind: + {"$decimal": "12.34"} -> decimal.Decimal("12.34") + {"$date": "2024-01-15"} -> datetime.date(2024, 1, 15) + {"$manual": ""} -> Fehler mit Klartext, da diese + Stelle noch von Hand ausgefüllt + werden muss. + """ + if isinstance(value, dict) and "$ref" in value: + if value["$ref"] not in created: + raise KeyError( + f"Referenz '{value['$ref']}' unbekannt - Datensatz mit " + f"diesem key wurde noch nicht angelegt oder ist " + f"fehlgeschlagen." + ) + return created[value["$ref"]] + if isinstance(value, dict) and "$decimal" in value: + return decimal.Decimal(value["$decimal"]) + if isinstance(value, dict) and "$date" in value: + return datetime.date.fromisoformat(value["$date"]) + if isinstance(value, dict) and "$manual" in value: + raise ValueError( + f"Nicht ausgefüllter $manual-Wert: {value['$manual']!r} - " + f"bitte im YAML durch einen echten Wert ersetzen, bevor " + f"dieser Datensatz angelegt wird." + ) + if isinstance(value, list): + return [resolve_value(v, created) for v in value] + if isinstance(value, dict): + return {k: resolve_value(v, created) for k, v in value.items()} + return value + + +def serialize(value): + """Proteus-/Tryton-Werte in eine JSON-taugliche, vergleichbare Form bringen.""" + if value is None: + return None + if hasattr(value, "id") and hasattr(value, "__class__"): + # Verknüpfter Record (Many2One o. ä.) - Modellname + id vergleichen, + # nicht das Objekt selbst. + return { + "__record__": getattr(value, "__class__").__name__, + "id": value.id, + } + if isinstance(value, (list, tuple)): + return [serialize(v) for v in value] + try: + json.dumps(value) + return value + except TypeError: + # Decimal, date, datetime, etc. - als String vergleichen + return str(value) + + +def create_records(spec, created, results): + fields_cache = {} # model_name -> Set der auf DIESEM Server bekannten Felder + + for entry in spec["records"]: + key = entry["key"] + model_name = entry["model"] + fields = entry.get("fields", {}) + + record_result = { + "key": key, + "model": model_name, + "status": "ok", + "error": None, + "stored": {}, + } + + try: + RecordModel = Model.get(model_name) + record = RecordModel() + + # actual_name je YAML-Feldname merken: fürs Zurücklesen unten + # brauchen wir denselben (ggf. per Alias aufgelösten) Namen, + # im Snapshot aber weiterhin den originalen YAML-Namen als Key. + actual_names = {} + for field_name, raw_value in fields.items(): + actual_name = resolve_field_name(RecordModel, model_name, field_name, fields_cache) + actual_names[field_name] = actual_name + setattr(record, actual_name, resolve_value(raw_value, created)) + + record.save() + created[key] = record.id + + # Bewusst NEU vom Server laden statt das lokale Proteus-Objekt + # weiterzuverwenden - das lokale Objekt kann noch den Wert + # zeigen, den WIR gesetzt haben, nicht den, den der Server + # tatsächlich abgespeichert (und ggf. reformatiert) hat. + reloaded = RecordModel(record.id) + for field_name in fields: + try: + record_result["stored"][field_name] = serialize( + getattr(reloaded, actual_names[field_name]) + ) + except Exception as e: + record_result["stored"][field_name] = f"" + + except Exception as e: + record_result["status"] = "error" + record_result["error"] = f"{type(e).__name__}: {e}" + record_result["traceback"] = traceback.format_exc() + + results.append(record_result) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--config", required=True, help="Pfad zur dataset.yaml/json") + parser.add_argument("--database", required=True, help="Name der Tryton-Datenbank") + parser.add_argument( + "--config-file", default=None, + help="Pfad zu trytond.conf, falls nicht der Standardpfad verwendet wird", + ) + parser.add_argument("--output", required=True, help="Wohin der JSON-Snapshot geschrieben wird") + args = parser.parse_args() + + # ACHTUNG: set_trytond() ist die lokale Variante (Proteus + trytond im + # selben Prozess/Server, kein separater Client-Server-Aufbau). Läuft + # euer trytond als eigener Prozess, braucht ihr stattdessen + # proteus_config.set_xmlrpc(url) mit einer URL wie + # "http://admin:PASSWORT@localhost:8000/mydb_68/". + proteus_config.set_trytond(database=args.database, config_file=args.config_file) + + spec = load_spec(args.config) + + created = {} + results = [] + create_records(spec, created, results) + + snapshot = {"database": args.database, "results": results} + Path(args.output).write_text( + json.dumps(snapshot, indent=2, ensure_ascii=False), encoding="utf-8" + ) + + ok = sum(1 for r in results if r["status"] == "ok") + err = sum(1 for r in results if r["status"] == "error") + print(f"{ok} Datensätze ok, {err} Fehler -> {args.output}") + if err: + print("Fehlgeschlagene Datensätze:") + for r in results: + if r["status"] == "error": + print(f" - {r['key']} ({r['model']}): {r['error']}") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/doc/MODELLVERGLEICH.md b/doc/MODELLVERGLEICH.md new file mode 100644 index 0000000..d0fc695 --- /dev/null +++ b/doc/MODELLVERGLEICH.md @@ -0,0 +1,96 @@ +# Modellbaum-Vergleich (5.0 ↔ 8.0) + +Werkzeug für die [Testdaten-Pipeline](TESTDATEN.md): Bevor Testdaten von +Hand ergänzt werden, erstmal statisch (kein laufendes Tryton nötig) +Schwarz auf Weiß sehen, welche Modelle/Felder es in einer Version +überhaupt gibt - damit weder Felder aus 8.0 übernommen werden, die es in +5.0 noch gar nicht gibt (würde beim Anlegen nur Fehler werfen), noch +Aufwand in Modelle gesteckt wird, die sich zwischen den Versionen gar +nicht verändert haben. + +## Workflow + +### 1. `extract_model_tree.py` – Modellbaum aus dem Quellcode ziehen + +Scannt den Python-Code ausgewählter Module per AST (kein Import, keine +laufende Instanz) und baut pro Modell (`__name__`) die Liste aller per +`fields.X(...)` definierten Felder, mit Typ, Relationsziel +(Many2One/One2Many/Many2Many/One2One/Reference) und - falls literal im +Code erkennbar - `required`. Modelle werden über PoolMeta-Erweiterungen +hinweg zusammengeführt: Fügt z. B. `stock_split` eine Klasse mit +`__name__ = 'stock.move'` hinzu, landen deren Felder unter demselben +Modell-Eintrag, mit Vermerk, aus welchem Modul sie stammen. + +Pro Modell wird zusätzlich `persisted` erkannt (erbt die Klasse `ModelSQL` +o. ä., oder nur `ModelView` - dann ist es ein reines Wizard-/ +Transient-Formular ohne eigene Tabelle). + +```bash +python3 extract_model_tree.py --repo /mnt/tryton \ + --modules company country currency party product ... \ + --output reports/model_tree_5.0.json --report reports/model_tree_5.0.md +``` + +Für eine zweite Version denselben Befehl gegen einen zweiten Checkout +laufen lassen (z. B. per `git worktree add /tmp/tryton-8.0 8.0`, ohne den +Haupt-Checkout umzuschalten). + +### 2. `model_diff.py` – zwei Modellbäume vergleichen + +Sortiert jedes Modell in eine von fünf Kategorien: + +- **entfernt** – Modell gibt es in Version A, nicht mehr in B +- **geändert** – Feld(er) entfernt oder Typ/Relation/required geändert → + echter Kandidat für einen Vergleichslauf +- **neu** – Modell gibt es erst in B +- **nur ergänzt** – nur neue Felder dazugekommen, Rest unverändert +- **unverändert** – komplett identisch geblieben + +```bash +python3 model_diff.py --tree-a reports/model_tree_5.0.json --label-a 5.0 \ + --tree-b reports/model_tree_8.0.json --label-b 8.0 \ + --output reports/model_diff.json --report reports/model_diff.md +``` + +### 3. `model_coverage.py` – gegen die aktuelle Testdaten-Abdeckung abgleichen + +Vergleicht einen Modellbaum mit einer gemergten `dataset.yaml` +(`reports/_testdata_merged.yaml`, siehe +[TESTDATEN.md](TESTDATEN.md)) und zeigt komplett unabgedeckte Modelle sowie +pro teilweise abgedecktem Modell die ungenutzten Felder (required zuerst). + +Drei Kategorien werden aus der Liste unabgedeckter Modelle per Default +herausgefiltert (nie von Hand testdatenrelevant, jeweils per Flag wieder +einschaltbar): + +- `ir.*`/`res.*`-Kernmodelle (`--include-framework`) +- Wizard-/Transient-Formulare, `persisted: false` (`--include-transient`) +- automatisch verwaltete Many2Many-Verknüpfungstabellen, erkennbar am + Bindestrich im Namen wie `party.party-party.category` + (`--include-relations`) + +Mit `--diff reports/model_diff.json` wird zusätzlich pro Modell die +Diff-Kategorie aus Schritt 2 eingeblendet und die Liste danach sortiert: +`geändert`/`entfernt` zuerst (lohnt sich, dort Testdaten zu ergänzen), +`nur ergänzt`/`unverändert` zuletzt (dort ist über den reinen +Codevergleich hinaus erstmal nichts Auffälliges zu erwarten). + +```bash +python3 model_coverage.py --model-tree reports/model_tree_5.0.json \ + --dataset reports/5_testdata_merged.yaml --diff reports/model_diff.json \ + --report reports/coverage_5.0.md +``` + +## Bekannte Grenzen + +- Rein statische Analyse: Felder, die nicht als einfaches + `name = fields.X(...)` auf Klassenebene stehen (z. B. per Schleife/Helper + dynamisch erzeugt), werden nicht erkannt. +- `persisted`-Erkennung ist eine Textsuche über die Basisklassen-Ausdrücke + (`ModelSQL`/`Workflow`/`DeactivableMixin`) - deckt den Normalfall ab, ist + aber kein echtes Type-Checking. +- Erkennt nur Unterschiede auf Ebene der Feld-**Definition** im Code + (Typ/Relation/required). Laufzeitverhalten wie Constraints, Defaults oder + DB-Spaltenpräzision kann trotzdem abweichen, ohne hier aufzufallen - dafür + bleibt der eigentliche Testlauf über `create_dataset.py`/ + `compare_snapshots.py` nötig. diff --git a/doc/TESTDATEN.md b/doc/TESTDATEN.md new file mode 100644 index 0000000..2dddf07 --- /dev/null +++ b/doc/TESTDATEN.md @@ -0,0 +1,105 @@ +# Proteus-Testdaten-Pipeline + +Ergänzender Ansatz zur [Codeanalyse](UPDATEANALYSE.md): Statt den +`__register__`-Code zu lesen, wird ein deklarativ definierter Testdatensatz +über Proteus in zwei frisch installierten Tryton-Instanzen (5.0 und 8.0) +tatsächlich angelegt. Ziel ist, dieselbe Datei gegen beide Versionen laufen +zu lassen, damit sowohl die Skript-Ausgabe (`compare_snapshots.py`) als +auch anschließend die SQL-Dumps beider Datenbanken vergleichbar sind - +dafür müssen inhaltlich identische Daten in derselben Reihenfolge +eingespielt werden. + +## Workflow + +``` +tests/scenario_*.rst (Tryton-Repo, pro Modul) + │ rst_to_dataset.py + ▼ +rsts/e/*.yaml (ein YAML-Record pro angelegtem Proteus-Objekt) + │ rsts_merge_dedup.py + ▼ +reports/_testdata_merged.yaml (dedupliziert, abhängigkeitskorrekt sortiert) + │ create_dataset.py --database ... + ▼ +snapshot_.json + │ compare_snapshots.py snapshot_a.json snapshot_b.json + ▼ +Fund-Liste: status_changed / value_changed / missing_record +``` + +### 1. `rst_to_dataset.py` – Testdaten aus den Modul-eigenen Tests extrahieren + +Tryton-Module bringen eigene `tests/scenario_*.rst`-Doctests mit (ausführbarer +Proteus-Code in `>>>`-Zeilen). Das Skript parst diese Dateien per AST und +erkennt: + +``` +>>> Party = Model.get('party.party') +>>> party = Party(name='Testfirma GmbH') +>>> party.vat_number = '123' +>>> party.save() +``` + +→ wird zu einem YAML-Record mit `key`, `model`, `fields`. Referenzen auf +zuvor im selben File angelegte Records werden zu `{"$ref": "..."}`, +`Decimal(...)`/`date(...)` zu `{"$decimal": ...}`/`{"$date": ...}`. Alles +nicht automatisch Auflösbare (Wizards, `.click(...)`, Helper-Funktionsaufrufe) +wird als `{"$manual": ""}` markiert oder ganz übersprungen - +bewusst sichtbar unvollständig statt still falsch. + +Record-Keys werden mit dem Dateinamen präfixiert, damit beim +Zusammenführen mehrerer Module keine Kollisionen entstehen. + +### 2. `rsts_merge_dedup.py` – pro Version zusammenführen + +Liest alle `rsts/e/*.yaml` eines Verzeichnisses ein und entfernt +Records mit identischem `model`+`fields` (z. B. dasselbe +Basis-`product.template`, das in vielen Szenarien wiederverwendet wird). +`$ref`-Verweise auf entfernte Duplikate werden auf den behaltenen Record +umgeschrieben. Danach wird per Kahn-Algorithmus so sortiert, dass +`$ref`-Abhängigkeiten immer VOR dem referenzierenden Record stehen, aber +innerhalb der Freiheitsgrade weiterhin nach `model` gruppiert wird. + +**Achtung:** Dedupliziert bewusst GLOBAL, auch innerhalb derselben Datei. +Bei Szenarien, die zwei absichtlich gleich aussehende Records anlegen (z. B. +`scenario_party_replace.rst`: zwei Parteien namens "Pam", um eine zu +ersetzen), verändert das den Sinn des Szenarios - für einen groben +Testdatensatz ist das in Ordnung, für szenario-treue Tests nicht. + +### 3. `create_dataset.py` – gegen eine echte Instanz anlegen + +Legt die Records der Reihe nach per Proteus an, liest jeden Wert danach +FRISCH VOM SERVER zurück (nicht aus dem lokalen Proteus-Cache), damit +automatische Reformatierung sichtbar wird. Ergebnis: ein JSON-Snapshot +(`status`/`error`/`stored` pro Record). + +**Feld-Umbenennungen zwischen Versionen** (`FIELD_RENAMES`): Da dieselbe +YAML gegen mehrere Versionen laufen soll, aber Felder umbenannt werden +können (bestätigt: `stock.move.uom` → `stock.move.unit` zwischen 5.0 und +8.0), prüft das Skript pro Modell zuerst per `fields_get()`, ob der +YAML-Feldname auf dem jeweiligen Server existiert, und weicht sonst auf +einen bekannten, bidirektionalen Alias aus. Ein wirklich unbekanntes Feld +bleibt trotzdem ein Fehler - das ist ja gerade das gesuchte Signal für eine +echte Schema-Änderung. Weitere Umbenennungen bei Bedarf in `FIELD_RENAMES` +ergänzen, sobald ein Lauf sie aufdeckt. + +### 4. `compare_snapshots.py` – zwei Versionen gegenüberstellen + +Vergleicht zwei Snapshots (gleiche YAML, zwei Versionen/Datenbanken) und +markiert `status_changed` (ein Record schlägt nur in einer Version fehl - +Kandidat für Format-/Constraint-/Pflichtfeld-Änderung), `value_changed` +(gespeicherter Wert weicht trotz gleichem Input ab - automatische +Reformatierung) und `missing_record`. + +## Stand + +- `rst_to_dataset.py` und `rsts_merge_dedup.py` sind gegen echte + `scenario_*.rst`-Dateien aus `/mnt/tryton` (5.0- und 8.0-Branch) getestet, + siehe `reports/5_testdata_merged.yaml` / `reports/8_testdata_merged.yaml` + (jeweils NUR aus den Szenarien der jeweiligen Version extrahiert, noch + NICHT zu einer gemeinsamen Datei zusammengeführt). +- `create_dataset.py` und `compare_snapshots.py` sind noch nicht gegen eine + echte Tryton-Instanz gelaufen (nur syntaktisch geprüft). +- Welche Modelle/Felder überhaupt Testdaten brauchen bzw. wo sich 5.0 und + 8.0 tatsächlich unterscheiden, siehe [MODELLVERGLEICH.md](MODELLVERGLEICH.md) + - das steuert, wo als Nächstes von Hand YAML-Records ergänzt werden. \ No newline at end of file diff --git a/UPDATEANALYSE.md b/doc/UPDATEANALYSE.md similarity index 79% rename from UPDATEANALYSE.md rename to doc/UPDATEANALYSE.md index a0f3536..6ea468a 100644 --- a/UPDATEANALYSE.md +++ b/doc/UPDATEANALYSE.md @@ -11,18 +11,18 @@ ausführen – ohne die Module tatsächlich zu installieren/upzudaten. ``` Checkt der Reihe nach jeden Versions-Branch (`5.0` bis `8.0`) im -Tryton-Repo aus, lässt `extract.py` pro Version über alle konfigurierten +Tryton-Repo aus, lässt `extract_updates.py` pro Version über alle konfigurierten Module laufen (Ergebnis: `data//.json`), und ruft danach -`compare.py` auf, das daraus die aggregierten Reports in `reports/*.md` +`compare_updates.py` auf, das daraus die aggregierten Reports in `reports/updateChanges/*.md` erzeugt (ein Report pro Modul, gegliedert nach Tabelle und Version). Einzeln aufrufbar: ```bash -python3 extract.py --repo --output data -python3 compare.py +python3 extract_updates.py --repo --output data +python3 compare_updates.py ``` -## Was `extract.py` erkennt +## Was `extract_updates.py` erkennt - Erkannte DB-Operationen (`column_rename`, `add_column`, `update`, `insert`, `execute`, ... – siehe `INTERESTING_OPS`) inkl. Tabelle(n), @@ -36,7 +36,7 @@ python3 compare.py um bekanntes Rauschen (`Pool()`, `Transaction()`, `cursor`, `.append`, `pool.get`, `logger.*`, `__table__`/`__table_handler__`). -## Was `extract.py` NICHT erkennt (bewusste Grenzen) +## Was `extract_updates.py` NICHT erkennt (bewusste Grenzen) - **Cross-Datei-Aufrufe**: Ruft `__register__` eine Funktion aus einem anderen Modul/Utility-Modul auf (z. B. `migrate_property(...)` aus @@ -48,7 +48,7 @@ python3 compare.py - **Implizite Schema-Änderungen** durch reine Feldtyp-Änderungen im Python-Code (ohne expliziten `add_column`/`alter_size`-Aufruf). -## `compare.py` – Aggregation & Dedup +## `compare_updates.py` – Aggregation & Dedup Fasst pro Tabelle die Operationen aller Versionen zusammen und zeigt eine Operation nur dann erneut an, wenn sie sich vom **tatsächlichen, @@ -63,17 +63,16 @@ Zeigt keine "wurde entfernt"-Markierung – nur Neues/Verändertes. ## Konfiguration -- Modul-/Repo-Defaults: oben in `extract.py` (`DEFAULT_REPO`, +- Modul-/Repo-Defaults: oben in `extract_updates.py` (`DEFAULT_REPO`, `DEFAULT_MODULES`). - Versions-Range: `START`/`END` in `run.sh`. -- Rauschfilter für `unresolved`: `IGNORED_UNRESOLVED_*` in `extract.py` – +- Rauschfilter für `unresolved`: `IGNORED_UNRESOLVED_*` in `extract_updates.py` – bei Bedarf erweitern, wenn sich beim Sichten neue, eindeutig irrelevante Muster zeigen (siehe Git-Historie für die bisherige Herleitung). -## Nächster Schritt +## Verwandter Zweig -Ergänzender, unabhängiger Zweig: Proteus-basierter Vergleich (echte +Ergänzender, unabhängiger Ansatz: Proteus-basierter Vergleich (echte Testdaten in zwei frisch installierten Versionen anlegen, Fehler/ -Reformatierung erkennen) – siehe `create_dataset.py`, -`compare_snapshots.py`, `rst_to_dataset.py` (Stand: ungetestet gegen -echte Tryton-Instanz). +Reformatierung erkennen) – siehe [doc/TESTDATEN.md](TESTDATEN.md) und +[doc/MODELLVERGLEICH.md](MODELLVERGLEICH.md). diff --git a/extract_model_tree.py b/extract_model_tree.py new file mode 100644 index 0000000..a455c69 --- /dev/null +++ b/extract_model_tree.py @@ -0,0 +1,244 @@ +#!/usr/bin/env python3 +""" +extract_model_tree.py + +Scannt den Python-Quellcode ausgewählter Tryton-Module (statisch per AST, +keine laufende Instanz nötig) und baut daraus einen Modellbaum: pro Modell +(__name__) alle per fields.X(...) definierten Felder, mit Typ, +Relationsziel (bei Many2One/One2Many/Many2Many/One2One/Reference) und - +falls literal im Code erkennbar - ob das Feld required ist. + +Modelle werden über PoolMeta-Erweiterungen hinweg zusammengeführt: Fügt +z. B. stock_split eine Klasse mit __name__ = 'stock.move' hinzu, landen +deren Felder unter demselben Modell-Eintrag, mit Vermerk, aus welchem +Modul sie stammen. + +Zweck hier: BEVOR versucht wird, dieselbe dataset.yaml gegen 5.0 und 8.0 +laufen zu lassen, erstmal Schwarz auf Weiß sehen, welche Modelle/Felder in +der 5.0-Codebasis (bei den tatsächlich aktiven Modulen) überhaupt +existieren - damit weder Modelle/Felder aus 8.0 übernommen werden, die es +in 5.0 noch gar nicht gibt (das würde nur Fehler werfen), noch Modelle im +Datensatz fehlen, für die aktuell kein *.rst-Testszenario existiert. + +Nutzung: + python3 extract_model_tree.py --repo /mnt/tryton \\ + --modules company country currency party product \\ + product_measurements production production_split \\ + stock stock_lot stock_product_location \\ + stock_shipment_measurements stock_split \\ + --output reports/model_tree_5.0.json --report reports/model_tree_5.0.md + +Ohne --modules wird DEFAULT_MODULES (unten) verwendet. + +WICHTIG: Rein statische Analyse. Felder, die nicht als einfaches +"name = fields.X(...)" auf Klassenebene stehen (z. B. per Schleife/ +Helper-Funktion dynamisch erzeugt), werden nicht erkannt - kommt in der +Praxis selten vor, aber nicht ausgeschlossen. +""" + +import argparse +import ast +import json +import sys +from pathlib import Path + +DEFAULT_REPO = "/mnt/tryton" + +DEFAULT_MODULES = [ + "ir", + "res", + "company", + "country", + "currency", + "party", + "product", + "product_measurements", + "production", + "production_split", + "stock", + "stock_lot", + "stock_lot_sled", + "stock_product_location", + "stock_shipment_measurements", + "stock_split", +] + +RELATIONAL_TYPES = {"Many2One", "One2Many", "Many2Many", "One2One", "Reference"} + + +def find_name_assignment(class_body): + """Sucht `__name__ = '...'` direkt im Klassenkörper.""" + for stmt in class_body: + if ( + isinstance(stmt, ast.Assign) + and len(stmt.targets) == 1 + and isinstance(stmt.targets[0], ast.Name) + and stmt.targets[0].id == "__name__" + and isinstance(stmt.value, ast.Constant) + and isinstance(stmt.value.value, str) + ): + return stmt.value.value + return None + + +def fields_call_info(call): + """Wenn `call` ein fields.(...)-Aufruf ist, gibt (Typ, Relation, + required, is_function, has_setter) zurück, sonst None.""" + if not isinstance(call, ast.Call) or not isinstance(call.func, ast.Attribute): + return None + if not isinstance(call.func.value, ast.Name) or call.func.value.id != "fields": + return None + field_type = call.func.attr + + relation = None + if field_type in RELATIONAL_TYPES and call.args: + first = call.args[0] + if isinstance(first, ast.Constant) and isinstance(first.value, str): + relation = first.value + else: + relation = "" + + is_function = field_type == "Function" + has_setter = False + if is_function: + # fields.Function(fields.Char(...), 'getter', setter='setter_name') + if len(call.args) >= 1: + inner = fields_call_info(call.args[0]) + if inner: + field_type = f"Function[{inner[0]}]" + has_setter = any(kw.arg == "setter" for kw in call.keywords) + + required = None + for kw in call.keywords: + if kw.arg == "required" and isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, bool): + required = kw.value.value + + return field_type, relation, required, is_function, has_setter + + +def is_persisted_class(node): + """True, wenn die Klasse ModelSQL (direkt oder z. B. via Workflow, das + selbst von ModelSQL erbt - daher genügt eine Textsuche über alle + Basisklassen-Ausdrücke) als Basis hat - Unterscheidungsmerkmal + zwischen echten, persistenten Modellen und reinen Wizard-/ + Transient-Formularen (die nur ModelView erben).""" + for base in node.bases: + try: + text = ast.unparse(base) + except Exception: + continue + if "ModelSQL" in text or "Workflow" in text or "DeactivableMixin" in text: + return True + return False + + +def scan_file(path, module_name, module_dir, models, persisted): + try: + tree = ast.parse(path.read_text(encoding="utf-8")) + except (SyntaxError, UnicodeDecodeError) as e: + print(f" WARNUNG: {path} übersprungen ({e})", file=sys.stderr) + return + + for node in ast.walk(tree): + if not isinstance(node, ast.ClassDef): + continue + model_name = find_name_assignment(node.body) + if not model_name: + continue + + if is_persisted_class(node): + persisted.add(model_name) + + model = models.setdefault(model_name, {}) + for stmt in node.body: + if not ( + isinstance(stmt, ast.Assign) + and len(stmt.targets) == 1 + and isinstance(stmt.targets[0], ast.Name) + ): + continue + field_name = stmt.targets[0].id + info = fields_call_info(stmt.value) + if info is None: + continue + field_type, relation, required, is_function, has_setter = info + model[field_name] = { + "type": field_type, + "relation": relation, + "required": required, + "settable": (not is_function) or has_setter, + "module": module_name, + "file": f"{module_name}/{path.relative_to(module_dir)}", + } + + +def module_directory(repo, module_name): + """ir/res liegen als Kernbestandteil in trytond/trytond/, nicht unter + modules/ wie die regulären (nachinstallierbaren) Module.""" + if module_name in ("ir", "res"): + return Path(repo) / "trytond" / "trytond" / module_name + return Path(repo) / "modules" / module_name + + +def scan_modules(repo, modules): + models = {} + persisted = set() + for module_name in modules: + module_dir = module_directory(repo, module_name) + if not module_dir.is_dir(): + print(f"WARNUNG: Modul '{module_name}' nicht gefunden unter {module_dir}", file=sys.stderr) + continue + for path in sorted(module_dir.rglob("*.py")): + if "tests" in path.relative_to(module_dir).parts: + continue + scan_file(path, module_name, module_dir, models, persisted) + + return { + model_name: {"persisted": model_name in persisted, "fields": fields} + for model_name, fields in models.items() + } + + +def write_report(models, out_path, modules): + lines = [f"# Modellbaum ({', '.join(modules)})\n"] + for model_name in sorted(models): + fields = models[model_name]["fields"] + if not fields: + continue + contributing_modules = sorted({f["module"] for f in fields.values()}) + transient_note = "" if models[model_name]["persisted"] else " _(Wizard/Transient - nicht persistent)_" + lines.append(f"\n## `{model_name}`{transient_note} _(Felder aus: {', '.join(contributing_modules)})_\n") + for field_name in sorted(fields): + f = fields[field_name] + parts = [f["type"]] + if f["relation"]: + parts.append(f"-> `{f['relation']}`") + if f["required"] is True: + parts.append("required") + if not f["settable"]: + parts.append("NICHT setzbar (Function ohne setter)") + if f["module"] != model_name.split(".")[0]: + parts.append(f"(aus Modul `{f['module']}`)") + lines.append(f"- **{field_name}**: {' '.join(parts)}") + out_path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("--repo", default=DEFAULT_REPO, help="Pfad zum Tryton-Repo-Checkout") + parser.add_argument("--modules", nargs="+", default=DEFAULT_MODULES, help="Zu scannende Modulnamen") + parser.add_argument("--output", default="reports/model_tree.json", help="JSON-Ausgabe (maschinenlesbar)") + parser.add_argument("--report", default="reports/model_tree.md", help="Markdown-Report (menschenlesbar)") + args = parser.parse_args() + + models = scan_modules(args.repo, args.modules) + + Path(args.output).write_text(json.dumps(models, indent=2, ensure_ascii=False, sort_keys=True), encoding="utf-8") + write_report(models, Path(args.report), args.modules) + + total_fields = sum(len(m["fields"]) for m in models.values()) + print(f"{len(models)} Modelle, {total_fields} Felder -> {args.output}, {args.report}") + + +if __name__ == "__main__": + main() diff --git a/extract.py b/extract_updates.py similarity index 100% rename from extract.py rename to extract_updates.py diff --git a/model_coverage.py b/model_coverage.py new file mode 100644 index 0000000..1bb466f --- /dev/null +++ b/model_coverage.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +""" +model_coverage.py + +Vergleicht den per extract_model_tree.py ermittelten Modellbaum (was gibt +es in der 5.0-Codebasis wirklich an Modellen/Feldern) mit dem aktuellen +Stand einer aus *.rst-Szenarien gemergten dataset.yaml (was wird davon +schon durch Testdaten abgedeckt). + +Zeigt: + - Modelle, die es in 5.0 gibt, aber für die noch KEIN Record in der + dataset.yaml existiert (komplett unabgedeckt). + - Pro abgedecktem Modell: setzbare Felder (keine reinen Function-Felder + ohne setter), die von keinem Record verwendet werden - required + zuerst, da dort eher etwas fehlt, das für's Anlegen nötig wäre. + +Für die Liste der komplett unabgedeckten Modelle werden per Default drei +Kategorien ausgeblendet, die man ohnehin nie händisch mit Testdaten +befüllt (jeweils per Flag reaktivierbar): + - ir.*/res.*-Kernmodelle (--include-framework) + - Wizard-/Transient-Formulare, die nur ModelView statt ModelSQL erben, + laut extract_model_tree.py also "persisted": false (--include-transient) + - automatisch verwaltete Many2Many-Verknüpfungstabellen, erkennbar am + Bindestrich im Modellnamen wie "party.party-party.category" + (--include-relations) + +Mit --diff (Ausgabe von model_diff.py, z. B. model_diff.json aus einem +5.0->8.0-Vergleich) wird zusätzlich pro Modell vermerkt, ob es sich +zwischen den Versionen überhaupt geändert hat, und danach sortiert: +"geändert"/"entfernt" zuerst (echte Kandidaten für einen Vergleichslauf), +"nur ergänzt"/"unverändert" zuletzt (dort ist über den Codevergleich +hinaus erstmal nichts Auffälliges zu erwarten). + +Nutzung: + python3 model_coverage.py --model-tree reports/model_tree_5.0.json \\ + --dataset reports/5_testdata_merged.yaml --diff reports/model_diff.json \\ + --report reports/coverage_5.0.md +""" + +import argparse +import json +from pathlib import Path + +try: + import yaml +except ImportError: + yaml = None + + +def load_records(path): + text = Path(path).read_text(encoding="utf-8") + if yaml is not None: + return yaml.safe_load(text)["records"] + return json.loads(text)["records"] + + +def used_fields_by_model(records): + used = {} + for r in records: + used.setdefault(r["model"], set()).update(r["fields"].keys()) + return used + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("--model-tree", required=True, help="JSON von extract_model_tree.py") + parser.add_argument("--dataset", required=True, help="Gemergte dataset.yaml/json") + parser.add_argument("--report", required=True, help="Ziel-Markdown-Datei") + parser.add_argument( + "--include-framework", action="store_true", + help="ir.*/res.*-Kernmodelle in der Liste unabgedeckter Modelle NICHT herausfiltern", + ) + parser.add_argument( + "--include-transient", action="store_true", + help="Wizard-/Transient-Formulare (persisted=false) NICHT herausfiltern", + ) + parser.add_argument( + "--include-relations", action="store_true", + help="Many2Many-Verknüpfungstabellen (Bindestrich im Namen) NICHT herausfiltern", + ) + parser.add_argument( + "--diff", default=None, + help="Optional: model_diff.json - blendet die Diff-Kategorie ein und " + "sortiert 'geändert'/'entfernt' nach oben", + ) + args = parser.parse_args() + + tree = json.loads(Path(args.model_tree).read_text(encoding="utf-8")) + records = load_records(args.dataset) + used = used_fields_by_model(records) + + diff = json.loads(Path(args.diff).read_text(encoding="utf-8")) if args.diff else {} + PRIORITY = {"geändert": 0, "entfernt": 1, "neu": 2, "nur ergänzt": 3, "unverändert": 4} + + def priority(model_name): + if not diff: + return 0 # ohne --diff: keine Umsortierung, alphabetische Reihenfolge bleibt + category = diff.get(model_name, {}).get("category") + return PRIORITY.get(category, 5) + + def diff_note(model_name): + if not diff: + return "" + category = diff.get(model_name, {}).get("category", "nicht in beiden Bäumen") + return f" _[{category}]_" + + uncovered_models = [] + partially_covered = [] + skipped = {"framework": 0, "transient": 0, "relation": 0} + + for model_name in sorted(tree): + entry = tree[model_name] + fields = entry["fields"] + settable = {name for name, info in fields.items() if info["settable"]} + if not settable: + continue # z.B. reine Log-/History-Modelle ohne setzbare Felder + + if model_name not in used: + if not args.include_framework and ( + model_name.startswith("ir.") or model_name.startswith("res.") + ): + skipped["framework"] += 1 + continue + if not args.include_transient and not entry["persisted"]: + skipped["transient"] += 1 + continue + if not args.include_relations and "-" in model_name: + skipped["relation"] += 1 + continue + uncovered_models.append(model_name) + continue + + missing = settable - used[model_name] + if missing: + missing_required = sorted(f for f in missing if fields[f]["required"] is True) + missing_optional = sorted(f for f in missing if fields[f]["required"] is not True) + partially_covered.append((model_name, missing_required, missing_optional)) + + uncovered_models.sort(key=priority) + partially_covered.sort(key=lambda item: priority(item[0])) + + lines = ["# Testdaten-Abdeckung gegen den 5.0-Modellbaum\n"] + + lines.append(f"\n## Komplett unabgedeckte Modelle ({len(uncovered_models)})\n") + lines.append("Für diese Modelle gibt es noch gar keinen Record in der dataset.yaml:\n") + for m in uncovered_models: + lines.append(f"- `{m}`{diff_note(m)}") + + lines.append(f"\n\n## Teilweise abgedeckte Modelle ({len(partially_covered)})\n") + lines.append("Modell hat mind. einen Record, aber nicht alle setzbaren Felder werden benutzt:\n") + for model_name, missing_required, missing_optional in partially_covered: + lines.append(f"\n### `{model_name}`{diff_note(model_name)}") + if missing_required: + lines.append(f"- **required, aber ungenutzt:** {', '.join(missing_required)}") + if missing_optional: + lines.append(f"- optional, ungenutzt: {', '.join(missing_optional)}") + + Path(args.report).write_text("\n".join(lines) + "\n", encoding="utf-8") + + skip_parts = [] + if skipped["framework"]: + skip_parts.append(f"{skipped['framework']} ir.*/res.*") + if skipped["transient"]: + skip_parts.append(f"{skipped['transient']} Wizard/Transient") + if skipped["relation"]: + skip_parts.append(f"{skipped['relation']} Verknüpfungstabellen") + note = f" ({', '.join(skip_parts)} ausgeblendet)" if skip_parts else "" + + print( + f"{len(uncovered_models)} Modelle komplett unabgedeckt{note}, " + f"{len(partially_covered)} teilweise abgedeckt -> {args.report}" + ) + + +if __name__ == "__main__": + main() diff --git a/model_diff.py b/model_diff.py new file mode 100644 index 0000000..e0e8fd1 --- /dev/null +++ b/model_diff.py @@ -0,0 +1,138 @@ +#!/usr/bin/env python3 +""" +model_diff.py + +Vergleicht zwei mit extract_model_tree.py erzeugte Modellbäume (z. B. +model_tree_5.0.json gegen model_tree_8.0.json) auf Modell- und Feldebene +und sortiert jedes Modell in eine von vier Kategorien: + + - entfernt: Modell gibt es in der ersten Version, aber nicht mehr + in der zweiten. + - neu: Modell gibt es erst in der zweiten Version. + - geändert: Modell existiert in beiden, aber mind. ein Feld wurde + entfernt oder hat sich (Typ/Relation/required) + geändert. Das sind die Kandidaten, bei denen sich ein + echter Testlauf gegen beide Versionen lohnt. + - unverändert / nur ergänzt: Modell ist identisch geblieben oder hat nur + zusätzliche Felder bekommen - hier ist über den reinen + Code-Vergleich hinaus erstmal nichts Auffälliges zu + erwarten (Laufzeitverhalten wie Constraints/Defaults + kann natürlich trotzdem abweichen, das sieht man mit + dieser rein statischen Analyse nicht). + +Nutzung: + python3 model_diff.py --tree-a reports/model_tree_5.0.json --label-a 5.0 \\ + --tree-b reports/model_tree_8.0.json --label-b 8.0 \\ + --output reports/model_diff.json --report reports/model_diff.md +""" + +import argparse +import json +from pathlib import Path + + +def diff_field(fa, fb): + changes = [] + if fa["type"] != fb["type"]: + changes.append(f"type: {fa['type']} -> {fb['type']}") + if fa["relation"] != fb["relation"]: + changes.append(f"relation: {fa['relation']} -> {fb['relation']}") + if fa["required"] != fb["required"]: + changes.append(f"required: {fa['required']} -> {fb['required']}") + return changes + + +def diff_trees(tree_a, tree_b): + result = {} + for model_name in sorted(set(tree_a) | set(tree_b)): + if model_name not in tree_b: + result[model_name] = {"category": "entfernt", "added": [], "removed": [], "changed": {}} + continue + if model_name not in tree_a: + result[model_name] = {"category": "neu", "added": [], "removed": [], "changed": {}} + continue + + fields_a = tree_a[model_name]["fields"] + fields_b = tree_b[model_name]["fields"] + added = sorted(set(fields_b) - set(fields_a)) + removed = sorted(set(fields_a) - set(fields_b)) + changed = {} + for name in sorted(set(fields_a) & set(fields_b)): + c = diff_field(fields_a[name], fields_b[name]) + if c: + changed[name] = c + + if removed or changed: + category = "geändert" + elif added: + category = "nur ergänzt" + else: + category = "unverändert" + + result[model_name] = { + "category": category, + "added": added, + "removed": removed, + "changed": changed, + } + return result + + +def write_report(diff, out_path, label_a, label_b): + by_category = {} + for model_name, info in diff.items(): + by_category.setdefault(info["category"], []).append(model_name) + + lines = [f"# Modellbaum-Diff: {label_a} -> {label_b}\n"] + for category, count_note in [ + ("entfernt", "Modell existiert nicht mehr"), + ("geändert", "Feld(er) entfernt oder geändert - Kandidat für einen echten Vergleichslauf"), + ("neu", f"Modell gibt es erst ab {label_b}"), + ("nur ergänzt", "nur neue Felder dazugekommen, Rest unverändert"), + ("unverändert", "komplett identisch geblieben"), + ]: + models = sorted(by_category.get(category, [])) + lines.append(f"\n## {category} ({len(models)}) - {count_note}\n") + for model_name in models: + info = diff[model_name] + if category == "geändert": + lines.append(f"\n### `{model_name}`") + if info["removed"]: + lines.append(f"- entfernte Felder: {', '.join(info['removed'])}") + for field_name, changes in info["changed"].items(): + lines.append(f"- **{field_name}**: {'; '.join(changes)}") + if info["added"]: + lines.append(f"- (zusätzlich neue Felder: {', '.join(info['added'])})") + else: + lines.append(f"- `{model_name}`") + + out_path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("--tree-a", required=True) + parser.add_argument("--tree-b", required=True) + parser.add_argument("--label-a", default="A") + parser.add_argument("--label-b", default="B") + parser.add_argument("--output", default="reports/model_diff.json") + parser.add_argument("--report", default="reports/model_diff.md") + args = parser.parse_args() + + tree_a = json.loads(Path(args.tree_a).read_text(encoding="utf-8")) + tree_b = json.loads(Path(args.tree_b).read_text(encoding="utf-8")) + + diff = diff_trees(tree_a, tree_b) + + Path(args.output).write_text(json.dumps(diff, indent=2, ensure_ascii=False, sort_keys=True), encoding="utf-8") + write_report(diff, Path(args.report), args.label_a, args.label_b) + + counts = {} + for info in diff.values(): + counts[info["category"]] = counts.get(info["category"], 0) + 1 + summary = ", ".join(f"{v} {k}" for k, v in counts.items()) + print(f"{summary} -> {args.output}, {args.report}") + + +if __name__ == "__main__": + main() diff --git a/reports/5_testdata_merged.yaml b/reports/5_testdata_merged.yaml new file mode 100644 index 0000000..ce2d1a3 --- /dev/null +++ b/reports/5_testdata_merged.yaml @@ -0,0 +1,532 @@ +{ + "records": [ + { + "key": "scenario_party_erase__party", + "model": "party.party", + "fields": { + "name": "Pam", + "active": false + } + }, + { + "key": "scenario_party_erase__attachment", + "model": "ir.attachment", + "fields": { + "resource": { + "$ref": "scenario_party_erase__party" + }, + "name": "Attachment" + } + }, + { + "key": "scenario_party_replace__party1", + "model": "party.party", + "fields": { + "name": "Pam" + } + }, + { + "key": "scenario_stock_lot_shipment_out__customer", + "model": "party.party", + "fields": { + "name": "Customer" + } + }, + { + "key": "scenario_stock_product_location__supplier", + "model": "party.party", + "fields": { + "name": "Suppier" + } + }, + { + "key": "scenario_stock_reporting__supplier", + "model": "party.party", + "fields": { + "name": "Supplier" + } + }, + { + "key": "scenario_stock_shipment_internal__employee_party", + "model": "party.party", + "fields": { + "name": "Employee" + } + }, + { + "key": "scenario_stock_shipment_internal__employee", + "model": "company.employee", + "fields": { + "party": { + "$ref": "scenario_stock_shipment_internal__employee_party" + } + } + }, + { + "key": "scenario_stock_shipment_out__employee", + "model": "company.employee", + "fields": { + "party": { + "$ref": "scenario_stock_shipment_internal__employee_party" + } + } + }, + { + "key": "scenario_production__template", + "model": "product.template", + "fields": { + "name": "product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "producible": true, + "list_price": { + "$decimal": "30" + } + } + }, + { + "key": "scenario_production__template1", + "model": "product.template", + "fields": { + "name": "component 1", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "5" + } + } + }, + { + "key": "scenario_production__template2", + "model": "product.template", + "fields": { + "name": "component 2", + "default_uom": { + "$manual": "meter" + }, + "type": "goods", + "list_price": { + "$decimal": "7" + } + } + }, + { + "key": "scenario_stock_average_cost_price__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "300" + }, + "cost_price_method": "average" + } + }, + { + "key": "scenario_stock_inventory__template2", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "kg" + }, + "type": "goods", + "list_price": { + "$decimal": "140" + }, + "cost_price_method": "average" + } + }, + { + "key": "scenario_stock_lot_shipment_out__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "20" + } + } + }, + { + "key": "scenario_production__bom", + "model": "production.bom", + "fields": { + "name": "product" + } + }, + { + "key": "scenario_production__production", + "model": "production", + "fields": { + "planned_date": { + "$manual": "today" + }, + "product": { + "$manual": "product" + }, + "bom": { + "$ref": "scenario_production__bom" + }, + "quantity": 2 + } + }, + { + "key": "scenario_production__production_lead_time", + "model": "production.lead_time", + "fields": { + "product": { + "$manual": "product" + }, + "bom": { + "$ref": "scenario_production__bom" + }, + "lead_time": { + "$manual": "datetime.timedelta(1)" + } + } + }, + { + "key": "scenario_stock_shipment_internal__stock_user", + "model": "res.user", + "fields": { + "name": "Stock", + "login": "stock", + "main_company": { + "$manual": "company" + }, + "employee": { + "$ref": "scenario_stock_shipment_internal__employee" + } + } + }, + { + "key": "scenario_stock_shipment_out__stock_user", + "model": "res.user", + "fields": { + "name": "Stock", + "login": "stock", + "main_company": { + "$manual": "company" + }, + "employee": { + "$ref": "scenario_stock_shipment_out__employee" + } + } + }, + { + "key": "scenario_stock_inventory__inventory", + "model": "stock.inventory", + "fields": { + "location": { + "$manual": "storage_loc" + }, + "empty_quantity": "keep" + } + }, + { + "key": "scenario_stock_inventory_empty_quantity__inventory", + "model": "stock.inventory", + "fields": { + "location": { + "$manual": "storage_loc" + }, + "empty_quantity": "empty" + } + }, + { + "key": "scenario_stock_average_cost_price__storage_sub_loc", + "model": "stock.location", + "fields": { + "name": "Storage Sub", + "type": "storage", + "parent": { + "$manual": "storage_loc" + } + } + }, + { + "key": "scenario_stock_product_location__child_loc", + "model": "stock.location", + "fields": { + "name": "Child Location", + "parent": { + "$manual": "storage_loc" + }, + "code": "CHI" + } + }, + { + "key": "scenario_stock_shipment_in_same_storage_input__storage1", + "model": "stock.location", + "fields": { + "name": "Storage 1", + "parent": { + "$manual": "storage_loc" + } + } + }, + { + "key": "scenario_stock_shipment_internal__internal_loc", + "model": "stock.location", + "fields": { + "name": "Internal", + "type": "storage" + } + }, + { + "key": "scenario_stock_shipment_internal__lead_time", + "model": "stock.location.lead_time", + "fields": { + "from_warehouse": { + "$manual": "storage_loc.warehouse" + }, + "to_warehouse": { + "$manual": "storage_loc.warehouse" + }, + "lead_time": { + "$manual": "datetime.timedelta(1)" + } + } + }, + { + "key": "scenario_stock_average_cost_price__incoming_move", + "model": "stock.move", + "fields": { + "product": { + "$manual": "product" + }, + "uom": { + "$manual": "unit" + }, + "quantity": 1, + "from_location": { + "$manual": "supplier_loc" + }, + "to_location": { + "$manual": "storage_loc" + }, + "planned_date": { + "$manual": "today" + }, + "effective_date": { + "$manual": "today" + }, + "company": { + "$manual": "company" + }, + "unit_price": { + "$decimal": "200" + }, + "currency": { + "$manual": "company.currency" + } + } + }, + { + "key": "scenario_stock_product_location__shipment_in", + "model": "stock.shipment.in", + "fields": { + "planned_date": { + "$manual": "today" + }, + "supplier": { + "$ref": "scenario_stock_product_location__supplier" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + }, + { + "key": "scenario_stock_reporting__shipment_in", + "model": "stock.shipment.in", + "fields": { + "planned_date": { + "$manual": "today" + }, + "supplier": { + "$ref": "scenario_stock_reporting__supplier" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + }, + { + "key": "scenario_stock_shipment_in_same_storage_input__shipment_in", + "model": "stock.shipment.in", + "fields": { + "supplier": { + "$ref": "scenario_stock_reporting__supplier" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + }, + { + "key": "scenario_stock_reporting__shipment_internal", + "model": "stock.shipment.internal", + "fields": { + "planned_date": { + "$manual": "today" + }, + "company": { + "$manual": "company" + }, + "from_location": { + "$manual": "storage_loc" + }, + "to_location": { + "$manual": "lost_loc" + } + } + }, + { + "key": "scenario_stock_shipment_internal__shipment", + "model": "stock.shipment.internal", + "fields": { + "planned_date": { + "$manual": "today" + }, + "from_location": { + "$ref": "scenario_stock_shipment_internal__internal_loc" + }, + "to_location": { + "$manual": "storage_loc" + } + } + }, + { + "key": "scenario_stock_lot_shipment_out__shipment_out", + "model": "stock.shipment.out", + "fields": { + "planned_date": { + "$manual": "today" + }, + "customer": { + "$ref": "scenario_stock_lot_shipment_out__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + }, + { + "key": "scenario_stock_reporting__shipment_out", + "model": "stock.shipment.out", + "fields": { + "planned_date": { + "$manual": "today" + }, + "customer": { + "$ref": "scenario_stock_lot_shipment_out__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + }, + { + "key": "scenario_stock_shipment_out__shipment_out", + "model": "stock.shipment.out", + "fields": { + "planned_date": { + "$manual": "today" + }, + "customer": { + "$ref": "scenario_stock_lot_shipment_out__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + }, + { + "key": "scenario_stock_shipment_out_same_storage_output__shipment_out", + "model": "stock.shipment.out", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_shipment_out__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + }, + { + "key": "scenario_stock_split_shipment__shipment1", + "model": "stock.shipment.out", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_shipment_out__customer" + } + } + }, + { + "key": "scenario_stock_product_location__shipment_out_return", + "model": "stock.shipment.out.return", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_shipment_out__customer" + }, + "supplier": { + "$ref": "scenario_stock_product_location__supplier" + }, + "from_location": { + "$manual": "output_loc" + }, + "to_location": { + "$manual": "supplier_loc" + } + } + }, + { + "key": "scenario_stock_shipment_out_return_same_storage_input__shipment", + "model": "stock.shipment.out.return", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_shipment_out__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + }, + "company": { + "$manual": "company" + } + } + } + ] +} \ No newline at end of file diff --git a/reports/8_testdata_merged.yaml b/reports/8_testdata_merged.yaml new file mode 100644 index 0000000..fb50d29 --- /dev/null +++ b/reports/8_testdata_merged.yaml @@ -0,0 +1,1252 @@ +{ + "records": [ + { + "key": "scenario_country_import__belgium", + "model": "country.country", + "fields": { + "name": "Belgium", + "code": "BE" + } + }, + { + "key": "scenario_party_phone_number__spain", + "model": "country.country", + "fields": { + "name": "Spain", + "code": "ES" + } + }, + { + "key": "scenario_currency_import__eur", + "model": "currency.currency", + "fields": { + "name": "Euro", + "symbol": "€", + "code": "EUR" + } + }, + { + "key": "scenario_production_lot_number__sequence", + "model": "ir.sequence", + "fields": { + "name": "Lot", + "sequence_type": { + "$manual": "sequence_type" + }, + "company": null + } + }, + { + "key": "scenario_stock_lot_number__sequence", + "model": "ir.sequence", + "fields": { + "name": "Lot", + "sequence_type": { + "$manual": "sequence_type" + } + } + }, + { + "key": "scenario_party_erase__party", + "model": "party.party", + "fields": { + "name": "Pam", + "active": false + } + }, + { + "key": "scenario_party_erase__attachment", + "model": "ir.attachment", + "fields": { + "resource": { + "$ref": "scenario_party_erase__party" + }, + "name": "Attachment" + } + }, + { + "key": "scenario_party_replace__party1", + "model": "party.party", + "fields": { + "name": "Pam" + } + }, + { + "key": "scenario_stock_lot_assign_try__customer", + "model": "party.party", + "fields": { + "name": "Customer" + } + }, + { + "key": "scenario_stock_lot_shipment_in__supplier", + "model": "party.party", + "fields": { + "name": "Supplier" + } + }, + { + "key": "scenario_stock_product_location__supplier", + "model": "party.party", + "fields": { + "name": "Suppier" + } + }, + { + "key": "scenario_stock_shipment_internal__employee_party", + "model": "party.party", + "fields": { + "name": "Employee" + } + }, + { + "key": "scenario_stock_shipment_internal__employee", + "model": "company.employee", + "fields": { + "party": { + "$ref": "scenario_stock_shipment_internal__employee_party" + } + } + }, + { + "key": "scenario_stock_shipment_out__employee", + "model": "company.employee", + "fields": { + "party": { + "$ref": "scenario_stock_shipment_internal__employee_party" + } + } + }, + { + "key": "scenario_stock_reporting_margin__category_root", + "model": "product.category", + "fields": { + "name": "Root" + } + }, + { + "key": "scenario_stock_reporting_margin__category1", + "model": "product.category", + "fields": { + "name": "Child1", + "parent": { + "$ref": "scenario_stock_reporting_margin__category_root" + } + } + }, + { + "key": "scenario_stock_reporting_margin__category2", + "model": "product.category", + "fields": { + "name": "Child2", + "parent": { + "$ref": "scenario_stock_reporting_margin__category_root" + } + } + }, + { + "key": "scenario_stock_lot_number__configuration", + "model": "product.configuration", + "fields": { + "default_lot_sequence": { + "$ref": "scenario_stock_lot_number__sequence" + } + } + }, + { + "key": "scenario_product_copy_locations__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "20" + } + } + }, + { + "key": "scenario_product_identifier__template", + "model": "product.template", + "fields": { + "name": "product", + "default_uom": { + "$manual": "unit" + }, + "type": "service" + } + }, + { + "key": "scenario_product_replace__template", + "model": "product.template", + "fields": { + "name": "Product", + "type": "goods", + "default_uom": { + "$manual": "kg" + } + } + }, + { + "key": "scenario_product_variant__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "list_price": { + "$decimal": "40.0000" + }, + "code": "PRD" + } + }, + { + "key": "scenario_product_variant__product2", + "model": "product.product", + "fields": { + "template": { + "$ref": "scenario_product_variant__template" + }, + "suffix_code": "002", + "list_price": { + "$decimal": "50.0000" + } + } + }, + { + "key": "scenario_production__template", + "model": "product.template", + "fields": { + "name": "product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "producible": true, + "list_price": { + "$decimal": "30" + } + } + }, + { + "key": "scenario_production__template1", + "model": "product.template", + "fields": { + "name": "component 1", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "5" + } + } + }, + { + "key": "scenario_production__template2", + "model": "product.template", + "fields": { + "name": "component 2", + "default_uom": { + "$manual": "meter" + }, + "type": "goods", + "list_price": { + "$decimal": "7" + } + } + }, + { + "key": "scenario_production_lot_number__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "10.0000" + }, + "lot_required": [ + "storage" + ], + "lot_sequence": { + "$ref": "scenario_production_lot_number__sequence" + } + } + }, + { + "key": "scenario_production_lot_trace__template", + "model": "product.template", + "fields": { + "name": "Product", + "type": "goods", + "default_uom": { + "$manual": "unit" + }, + "producible": true, + "list_price": { + "$decimal": "1" + } + } + }, + { + "key": "scenario_production_no_list_price__template", + "model": "product.template", + "fields": { + "name": "product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "producible": true + } + }, + { + "key": "scenario_production_phantom_bom__template_extension", + "model": "product.template", + "fields": { + "name": "extension", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "5" + } + } + }, + { + "key": "scenario_production_phantom_bom__template_foot", + "model": "product.template", + "fields": { + "name": "foot", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "5" + } + } + }, + { + "key": "scenario_production_phantom_bom__template_hook", + "model": "product.template", + "fields": { + "name": "hook", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "7" + } + } + }, + { + "key": "scenario_production_phantom_bom__template_leg", + "model": "product.template", + "fields": { + "name": "leg", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "producible": true, + "list_price": { + "$decimal": "7" + } + } + }, + { + "key": "scenario_production_phantom_bom__template_table", + "model": "product.template", + "fields": { + "name": "table", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "producible": true, + "list_price": { + "$decimal": "30" + } + } + }, + { + "key": "scenario_production_phantom_bom__template_top", + "model": "product.template", + "fields": { + "name": "top", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "5" + } + } + }, + { + "key": "scenario_production_set_cost__template", + "model": "product.template", + "fields": { + "name": "product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "producible": true, + "list_price": { + "$decimal": "20" + } + } + }, + { + "key": "scenario_stock_average_cost_price__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "300" + }, + "cost_price_method": "average" + } + }, + { + "key": "scenario_stock_inventory__template2", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "kg" + }, + "type": "goods", + "list_price": { + "$decimal": "140" + }, + "cost_price_method": "average" + } + }, + { + "key": "scenario_stock_lot_inventory_count__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "lot_required": [ + "storage" + ] + } + }, + { + "key": "scenario_stock_lot_number__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "lot_sequence": null + } + }, + { + "key": "scenario_stock_lot_shipment_out__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "20" + }, + "lot_required": [ + "storage" + ] + } + }, + { + "key": "scenario_stock_lot_trace__template", + "model": "product.template", + "fields": { + "name": "Product", + "type": "goods", + "default_uom": { + "$manual": "unit" + } + } + }, + { + "key": "scenario_stock_product_location_consumable__template", + "model": "product.template", + "fields": { + "name": "Consumable", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "consumable": true + } + }, + { + "key": "scenario_stock_recompute_average_cost_price_production__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "50.0000" + }, + "cost_price_method": "average" + } + }, + { + "key": "scenario_stock_reporting_margin__template", + "model": "product.template", + "fields": { + "name": "Product", + "default_uom": { + "$manual": "unit" + }, + "type": "goods", + "list_price": { + "$decimal": "40" + } + } + }, + { + "key": "scenario_production__bom", + "model": "production.bom", + "fields": { + "name": "product" + } + }, + { + "key": "scenario_production__production", + "model": "production", + "fields": { + "planned_date": { + "$manual": "today" + }, + "product": { + "$manual": "product" + }, + "bom": { + "$ref": "scenario_production__bom" + }, + "quantity": 2 + } + }, + { + "key": "scenario_production_phantom_bom__bom", + "model": "production.bom", + "fields": { + "name": "product with Phantom BoM" + } + }, + { + "key": "scenario_production_phantom_bom__phantom_bom_input", + "model": "production.bom", + "fields": { + "name": "Leg Foot Input", + "phantom": true, + "phantom_quantity": 1, + "phantom_unit": { + "$manual": "unit" + } + } + }, + { + "key": "scenario_production_phantom_bom__phantom_bom_output", + "model": "production.bom", + "fields": { + "name": "Extension Hook Ouput", + "phantom": true, + "phantom_quantity": 1, + "phantom_unit": { + "$manual": "unit" + } + } + }, + { + "key": "scenario_production_split__bom", + "model": "production.bom", + "fields": { + "name": "Product" + } + }, + { + "key": "scenario_production_split__production", + "model": "production", + "fields": { + "product": { + "$manual": "product" + }, + "bom": { + "$ref": "scenario_production_split__bom" + }, + "quantity": 10 + } + }, + { + "key": "scenario_production__production_lead_time", + "model": "production.lead_time", + "fields": { + "product": { + "$manual": "product" + }, + "bom": { + "$ref": "scenario_production__bom" + }, + "lead_time": { + "$manual": "dt.timedelta(1)" + } + } + }, + { + "key": "scenario_stock_shipment_internal__user", + "model": "res.user", + "fields": { + "employee": { + "$ref": "scenario_stock_shipment_internal__employee" + } + } + }, + { + "key": "scenario_stock_shipment_out__user", + "model": "res.user", + "fields": { + "employee": { + "$ref": "scenario_stock_shipment_out__employee" + } + } + }, + { + "key": "scenario_stock_inventory__inventory", + "model": "stock.inventory", + "fields": { + "location": { + "$manual": "storage_loc" + }, + "empty_quantity": "keep" + } + }, + { + "key": "scenario_stock_inventory_empty_quantity__inventory", + "model": "stock.inventory", + "fields": { + "location": { + "$manual": "storage_loc" + }, + "empty_quantity": "empty" + } + }, + { + "key": "scenario_product_copy_locations__child_loc", + "model": "stock.location", + "fields": { + "name": "Child Location", + "parent": { + "$manual": "storage_loc" + }, + "code": "CHI" + } + }, + { + "key": "scenario_stock_average_cost_price__storage_sub_loc", + "model": "stock.location", + "fields": { + "name": "Storage Sub", + "type": "storage", + "parent": { + "$manual": "storage_loc" + } + } + }, + { + "key": "scenario_stock_lot_assign_try__zone1", + "model": "stock.location", + "fields": { + "name": "Zone1", + "parent": { + "$manual": "storage_loc" + }, + "type": "storage" + } + }, + { + "key": "scenario_stock_product_location_consumable__consumable_loc", + "model": "stock.location", + "fields": { + "name": "Consumable", + "parent": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_recompute_average_cost_price_production__production_loc", + "model": "stock.location", + "fields": { + "name": "Production", + "type": "production" + } + }, + { + "key": "scenario_stock_shipment_in_same_storage_input__storage1", + "model": "stock.location", + "fields": { + "name": "Storage 1", + "parent": { + "$manual": "storage_loc" + } + } + }, + { + "key": "scenario_stock_shipment_internal__internal_loc", + "model": "stock.location", + "fields": { + "name": "Internal", + "type": "storage", + "parent": { + "$manual": "storage_loc.parent" + } + } + }, + { + "key": "scenario_stock_lot_shipment_out_internal__lead_time", + "model": "stock.location.lead_time", + "fields": { + "warehouse_from": { + "$manual": "warehouse1" + }, + "warehouse_to": { + "$manual": "warehouse2" + }, + "lead_time": { + "$manual": "dt.timedelta(1)" + } + } + }, + { + "key": "scenario_production_lot_trace__component_lot", + "model": "stock.lot", + "fields": { + "product": { + "$manual": "component" + }, + "number": "2" + } + }, + { + "key": "scenario_production_lot_trace__product_lot", + "model": "stock.lot", + "fields": { + "product": { + "$manual": "product" + }, + "number": "1" + } + }, + { + "key": "scenario_stock_lot_assign_try__lot", + "model": "stock.lot", + "fields": { + "number": "LOT", + "product": { + "$manual": "product" + } + } + }, + { + "key": "scenario_stock_lot_inventory_count__lot", + "model": "stock.lot", + "fields": { + "number": "0001", + "product": { + "$manual": "product" + } + } + }, + { + "key": "scenario_stock_lot_move_add__lot2", + "model": "stock.lot", + "fields": { + "number": "02", + "product": { + "$manual": "product" + } + } + }, + { + "key": "scenario_stock_lot_number__lot", + "model": "stock.lot", + "fields": { + "product": { + "$manual": "product" + } + } + }, + { + "key": "scenario_stock_lot_shipment_in__lot2", + "model": "stock.lot", + "fields": { + "number": "2", + "product": { + "$manual": "product" + } + } + }, + { + "key": "scenario_stock_average_cost_price__incoming_move", + "model": "stock.move", + "fields": { + "product": { + "$manual": "product" + }, + "unit": { + "$manual": "unit" + }, + "quantity": 1, + "from_location": { + "$manual": "supplier_loc" + }, + "to_location": { + "$manual": "storage_loc" + }, + "planned_date": { + "$manual": "today" + }, + "effective_date": { + "$manual": "today" + }, + "unit_price": { + "$decimal": "200" + }, + "currency": { + "$manual": "currency" + } + } + }, + { + "key": "scenario_stock_lot_move_add__move", + "model": "stock.move", + "fields": { + "from_location": { + "$manual": "storage_loc" + }, + "to_location": { + "$manual": "customer_loc" + }, + "product": { + "$manual": "product" + }, + "quantity": 10, + "unit_price": { + "$decimal": "20" + }, + "currency": { + "$manual": "get_currency()" + } + } + }, + { + "key": "scenario_stock_move_in_future__move", + "model": "stock.move", + "fields": { + "product": { + "$manual": "product" + }, + "quantity": 2, + "from_location": { + "$manual": "supplier_loc" + }, + "to_location": { + "$manual": "storage_loc" + }, + "currency": { + "$manual": "get_currency()" + }, + "effective_date": { + "$manual": "today" + }, + "unit_price": { + "$decimal": "1" + } + } + }, + { + "key": "scenario_stock_period__move", + "model": "stock.move", + "fields": { + "product": { + "$manual": "product" + }, + "quantity": 1, + "from_location": { + "$manual": "storage_loc" + }, + "to_location": { + "$manual": "customer_loc" + }, + "planned_date": { + "$manual": "yesterday" + }, + "unit_price": { + "$decimal": "42.0000" + }, + "currency": { + "$manual": "currency" + } + } + }, + { + "key": "scenario_stock_product_quantities_by_warehouse__move_2", + "model": "stock.move", + "fields": { + "product": { + "$manual": "product" + }, + "from_location": { + "$manual": "storage_loc" + }, + "to_location": { + "$manual": "customer_loc" + }, + "unit": { + "$manual": "unit" + }, + "quantity": 6, + "planned_date": { + "$manual": "tomorrow" + }, + "unit_price": { + "$decimal": "20" + }, + "currency": { + "$manual": "currency" + } + } + }, + { + "key": "scenario_stock_product_replace__move_2", + "model": "stock.move", + "fields": { + "product": { + "$manual": "product1" + }, + "quantity": 1, + "from_location": { + "$manual": "storage_loc" + }, + "to_location": { + "$manual": "customer_loc" + }, + "unit_price": { + "$decimal": "20.0000" + }, + "currency": { + "$manual": "company.currency" + } + } + }, + { + "key": "scenario_stock_reporting_inventory__move_2", + "model": "stock.move", + "fields": { + "product": { + "$manual": "product" + }, + "from_location": { + "$manual": "supplier_loc" + }, + "to_location": { + "$manual": "storage_loc" + }, + "quantity": 10, + "effective_date": { + "$manual": "dt.date(2025, 1, 5)" + }, + "unit_price": { + "$decimal": "10.0000" + }, + "currency": { + "$manual": "currency" + } + } + }, + { + "key": "scenario_stock_period__period", + "model": "stock.period", + "fields": { + "date": { + "$manual": "yesterday" + } + } + }, + { + "key": "scenario_stock_lot_shipment_in__shipment", + "model": "stock.shipment.in", + "fields": { + "supplier": { + "$ref": "scenario_stock_lot_shipment_in__supplier" + } + } + }, + { + "key": "scenario_stock_product_location__shipment_in", + "model": "stock.shipment.in", + "fields": { + "planned_date": { + "$manual": "today" + }, + "supplier": { + "$ref": "scenario_stock_product_location__supplier" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_product_location_template__shipment_in", + "model": "stock.shipment.in", + "fields": { + "planned_date": { + "$manual": "today" + }, + "supplier": { + "$ref": "scenario_stock_product_location__supplier" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_reporting__shipment_in", + "model": "stock.shipment.in", + "fields": { + "planned_date": { + "$manual": "today" + }, + "supplier": { + "$ref": "scenario_stock_lot_shipment_in__supplier" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_shipment_in__shipment", + "model": "stock.shipment.in", + "fields": { + "supplier": { + "$ref": "scenario_stock_lot_shipment_in__supplier" + } + } + }, + { + "key": "scenario_stock_shipment_in_same_storage_input__shipment_in", + "model": "stock.shipment.in", + "fields": { + "supplier": { + "$ref": "scenario_stock_lot_shipment_in__supplier" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_shipment_in_return__shipment_return", + "model": "stock.shipment.in.return", + "fields": { + "planned_date": { + "$manual": "yesterday" + }, + "supplier": { + "$ref": "scenario_stock_lot_shipment_in__supplier" + }, + "from_location": { + "$manual": "storage_loc" + } + } + }, + { + "key": "scenario_stock_lot_shipment_out_internal__shipment", + "model": "stock.shipment.internal", + "fields": { + "planned_date": { + "$manual": "tomorrow" + }, + "from_location": { + "$manual": "warehouse1.storage_location" + }, + "to_location": { + "$manual": "warehouse2.storage_location" + }, + "effective_start_date": { + "$manual": "yesterday" + } + } + }, + { + "key": "scenario_stock_reporting__shipment_internal", + "model": "stock.shipment.internal", + "fields": { + "planned_date": { + "$manual": "today" + }, + "from_location": { + "$manual": "storage_loc" + }, + "to_location": { + "$manual": "lost_loc" + } + } + }, + { + "key": "scenario_stock_shipment_internal__shipment", + "model": "stock.shipment.internal", + "fields": { + "planned_date": { + "$manual": "today" + }, + "from_location": { + "$ref": "scenario_stock_shipment_internal__internal_loc" + }, + "to_location": { + "$manual": "storage_loc" + } + } + }, + { + "key": "scenario_stock_lot_shipment_out__shipment_out", + "model": "stock.shipment.out", + "fields": { + "planned_date": { + "$manual": "today" + }, + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_reporting__shipment_out", + "model": "stock.shipment.out", + "fields": { + "planned_date": { + "$manual": "today" + }, + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_shipment_out__shipment_out", + "model": "stock.shipment.out", + "fields": { + "planned_date": { + "$manual": "today" + }, + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_shipment_out_same_storage_output__shipment_out", + "model": "stock.shipment.out", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_split_shipment__shipment1", + "model": "stock.shipment.out", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + } + } + }, + { + "key": "scenario_stock_product_location__shipment_out_return", + "model": "stock.shipment.out.return", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + } + } + }, + { + "key": "scenario_stock_product_location_template__shipment_out_return", + "model": "stock.shipment.out.return", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + } + } + }, + { + "key": "scenario_stock_shipment_out_return__shipment", + "model": "stock.shipment.out.return", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + }, + { + "key": "scenario_stock_shipment_out_return_same_storage_input__shipment", + "model": "stock.shipment.out.return", + "fields": { + "customer": { + "$ref": "scenario_stock_lot_assign_try__customer" + }, + "warehouse": { + "$manual": "warehouse_loc" + } + } + } + ] +} \ No newline at end of file diff --git a/reports/coverage_5.0.md b/reports/coverage_5.0.md new file mode 100644 index 0000000..f3aaf47 --- /dev/null +++ b/reports/coverage_5.0.md @@ -0,0 +1,103 @@ +# Testdaten-Abdeckung gegen den 5.0-Modellbaum + + +## Komplett unabgedeckte Modelle (35) + +Für diese Modelle gibt es noch gar keinen Record in der dataset.yaml: + +- `company.company` _[geändert]_ +- `country.subdivision` _[geändert]_ +- `currency.currency` _[geändert]_ +- `currency.currency.rate` _[geändert]_ +- `party.address` _[geändert]_ +- `party.address.format` _[geändert]_ +- `party.contact_mechanism` _[geändert]_ +- `product.cost_price` _[geändert]_ +- `product.list_price` _[geändert]_ +- `product.product` _[geändert]_ +- `production.bom.input` _[geändert]_ +- `stock.inventory.line` _[geändert]_ +- `stock.lot` _[geändert]_ +- `stock.product.location` _[geändert]_ +- `stock.shipment.in.return` _[geändert]_ +- `country.zip` _[entfernt]_ +- `stock.lot.type` _[entfernt]_ +- `country.country` _[nur ergänzt]_ +- `party.configuration` _[nur ergänzt]_ +- `party.identifier` _[nur ergänzt]_ +- `product.category` _[nur ergänzt]_ +- `product.configuration` _[nur ergänzt]_ +- `production.configuration` _[nur ergänzt]_ +- `stock.configuration` _[nur ergänzt]_ +- `party.category` _[unverändert]_ +- `party.party.lang` _[unverändert]_ +- `party.party.location` _[unverändert]_ +- `product.cost_price_method` _[unverändert]_ +- `product.uom` _[unverändert]_ +- `product.uom.category` _[unverändert]_ +- `production.configuration.production_sequence` _[unverändert]_ +- `stock.configuration.sequence` _[unverändert]_ +- `stock.period` _[unverändert]_ +- `stock.period.cache` _[unverändert]_ +- `stock.period.cache.lot` _[unverändert]_ + + +## Teilweise abgedeckte Modelle (15) + +Modell hat mind. einen Record, aber nicht alle setzbaren Felder werden benutzt: + + +### `product.template` _[geändert]_ +- optional, ungenutzt: categories, categories_all, consumable, cost_price_methods, expiration_state, expiration_time, height, height_uom, length, length_uom, list_prices, lot_required, products, shelf_life_state, shelf_life_time, volume, volume_uom, weight, weight_uom, width, width_uom + +### `production` _[geändert]_ +- **required, aber ungenutzt:** company, location, warehouse +- optional, ungenutzt: effective_date, effective_start_date, inputs, number, outputs, planned_start_date, reference, state, uom + +### `res.user` _[geändert]_ +- **required, aber ungenutzt:** menu +- optional, ungenutzt: actions, applications, company, email, employees, groups, language, password, password_hash, password_reset, password_reset_expire, signature, warnings + +### `stock.inventory` _[geändert]_ +- **required, aber ungenutzt:** company, date, lost_found +- optional, ungenutzt: lines, number, state + +### `stock.move` _[geändert]_ +- **required, aber ungenutzt:** internal_quantity +- optional, ungenutzt: cost_price, internal_volume, internal_weight, lot, origin, production_input, production_output, shipment, state + +### `stock.shipment.in` _[geändert]_ +- optional, ungenutzt: contact_address, effective_date, incoming_moves, inventory_moves, moves, number, reference, state + +### `stock.shipment.internal` _[geändert]_ +- optional, ungenutzt: effective_date, effective_start_date, incoming_moves, moves, number, outgoing_moves, planned_start_date, reference, state + +### `stock.shipment.out` _[geändert]_ +- **required, aber ungenutzt:** delivery_address +- optional, ungenutzt: effective_date, inventory_moves, moves, number, outgoing_moves, reference, state + +### `stock.shipment.out.return` _[geändert]_ +- **required, aber ungenutzt:** delivery_address +- optional, ungenutzt: effective_date, incoming_moves, inventory_moves, moves, number, planned_date, reference, state + +### `company.employee` _[nur ergänzt]_ +- **required, aber ungenutzt:** company +- optional, ungenutzt: end_date, start_date + +### `party.party` _[nur ergänzt]_ +- **required, aber ungenutzt:** code +- optional, ungenutzt: addresses, categories, contact_mechanisms, customer_location, identifiers, lang, langs, locations, replaced_by, supplier_location + +### `production.bom` _[nur ergänzt]_ +- optional, ungenutzt: inputs, output_products, outputs + +### `stock.location` _[nur ergänzt]_ +- **required, aber ungenutzt:** left, right +- optional, ungenutzt: address, childs, flat_childs, input_location, output_location, picking_location, production_location, storage_location + +### `ir.attachment` _[unverändert]_ +- **required, aber ungenutzt:** type +- optional, ungenutzt: data, description, file_id, link + +### `stock.location.lead_time` _[unverändert]_ +- optional, ungenutzt: warehouse_from, warehouse_to diff --git a/reports/model_diff.json b/reports/model_diff.json new file mode 100644 index 0000000..4bda76a --- /dev/null +++ b/reports/model_diff.json @@ -0,0 +1,2192 @@ +{ + "company.company": { + "added": [ + "logo", + "logo_cache", + "tax_identifiers" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "childs", + "parent" + ] + }, + "company.company.config": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "company.company.config.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "company.company.logo.cache": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "company.company.tax_identifier": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "company.employee": { + "added": [ + "active", + "subordinates", + "supervisor" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "country.country": { + "added": [ + "flag", + "members", + "organizations", + "region" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "country.organization": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "country.organization.member": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "country.postal_code": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "country.region": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "country.subdivision": { + "added": [ + "flag" + ], + "category": "geändert", + "changed": { + "code": [ + "required: True -> None" + ], + "type": [ + "required: True -> None" + ] + }, + "removed": [] + }, + "country.zip": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "currency.cron": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "currency.cron-currency.currency": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "currency.currency": { + "added": [], + "category": "geändert", + "changed": { + "symbol": [ + "required: True -> None" + ] + }, + "removed": [] + }, + "currency.currency.rate": { + "added": [], + "category": "geändert", + "changed": { + "currency": [ + "required: None -> True" + ], + "rate": [ + "required: None -> True" + ] + }, + "removed": [] + }, + "ir.action": { + "added": [ + "action", + "records" + ], + "category": "geändert", + "changed": { + "type": [ + "type: Char -> Selection" + ] + }, + "removed": [] + }, + "ir.action-res.group": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.action.act_window": { + "added": [], + "category": "geändert", + "changed": { + "domains": [ + "type: Function[Binary] -> Function[Field]" + ], + "views": [ + "type: Function[Binary] -> Function[Field]" + ] + }, + "removed": [ + "action" + ] + }, + "ir.action.act_window.domain": { + "added": [], + "category": "geändert", + "changed": {}, + "removed": [ + "sequence" + ] + }, + "ir.action.act_window.view": { + "added": [ + "model" + ], + "category": "geändert", + "changed": { + "act_window": [ + "required: None -> True" + ] + }, + "removed": [ + "sequence" + ] + }, + "ir.action.keyword": { + "added": [], + "category": "geändert", + "changed": { + "action": [ + "required: None -> True" + ], + "groups": [ + "type: Function[One2Many] -> Function[Many2Many]" + ] + }, + "removed": [] + }, + "ir.action.report": { + "added": [ + "record_name", + "report_content_html" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "action", + "email", + "pyson_email" + ] + }, + "ir.action.url": { + "added": [], + "category": "geändert", + "changed": {}, + "removed": [ + "action" + ] + }, + "ir.action.wizard": { + "added": [], + "category": "geändert", + "changed": {}, + "removed": [ + "action", + "email" + ] + }, + "ir.attachment": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.avatar": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.avatar.cache": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.cache": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.calendar.day": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.calendar.month": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.chat.channel": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.chat.follower": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.chat.message": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.configuration": { + "added": [ + "currency_rate_decimal", + "product_price_decimal", + "series" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "ir.cron": { + "added": [ + "day", + "hour", + "logs", + "method", + "minute", + "running", + "timezone", + "weekday" + ], + "category": "geändert", + "changed": { + "interval_type": [ + "required: None -> True" + ], + "next_call": [ + "required: True -> None" + ] + }, + "removed": [ + "args", + "function", + "model", + "name", + "number_calls", + "repeat_missed", + "request_user", + "user" + ] + }, + "ir.cron-company.company": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.cron.log": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.date": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.email": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.email.address": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.email.template": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.email.template-ir.action.report": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.error": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.export": { + "added": [ + "groups", + "header", + "ignore_search_limit", + "records", + "user", + "write_groups" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "ir.export-res.group": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.export-write-res.group": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.export.line": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.filestore.queue": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.lang": { + "added": [ + "am", + "nplurals", + "pg_text_search", + "plural", + "pm" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "ir.lang.config": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.lang.config.start": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.message": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.model": { + "added": [ + "string" + ], + "category": "geändert", + "changed": { + "fields": [ + "required: True -> None" + ], + "name": [ + "required: None -> True" + ] + }, + "removed": [ + "info", + "model" + ] + }, + "ir.model.access": { + "added": [], + "category": "geändert", + "changed": { + "model": [ + "type: Many2One -> Char", + "relation: ir.model -> None" + ] + }, + "removed": [] + }, + "ir.model.button": { + "added": [], + "category": "geändert", + "changed": { + "model": [ + "type: Many2One -> Char", + "relation: ir.model -> None" + ] + }, + "removed": [] + }, + "ir.model.button-button.reset": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.model.button-res.group": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.model.button.click": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.model.button.rule": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.model.data": { + "added": [ + "field_names" + ], + "category": "geändert", + "changed": { + "db_id": [ + "required: True -> None" + ] + }, + "removed": [ + "fs_values", + "out_of_sync", + "values" + ] + }, + "ir.model.field": { + "added": [ + "access", + "string" + ], + "category": "geändert", + "changed": { + "model": [ + "type: Many2One -> Char", + "relation: ir.model -> None" + ] + }, + "removed": [ + "field_description", + "groups" + ] + }, + "ir.model.field-res.group": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "ir.model.field.access": { + "added": [ + "model" + ], + "category": "geändert", + "changed": { + "field": [ + "type: Many2One -> Char", + "relation: ir.model.field -> None" + ] + }, + "removed": [] + }, + "ir.model.graph": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.model.log": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.model.print_model_graph": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.model.print_model_graph.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.model.refresh_materialized": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.model.workflow_graph": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module": { + "added": [], + "category": "geändert", + "changed": { + "childs": [ + "type: Function[One2Many] -> Function[Many2Many]" + ], + "parents": [ + "type: Function[One2Many] -> Function[Many2Many]" + ] + }, + "removed": [] + }, + "ir.module.activate_upgrade": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.activate_upgrade.done": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.activate_upgrade.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.config": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.config.start": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.module.config_wizard": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.config_wizard.done": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.config_wizard.first": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.config_wizard.item": { + "added": [], + "category": "geändert", + "changed": {}, + "removed": [ + "sequence" + ] + }, + "ir.module.config_wizard.other": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.module.dependency": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.note": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.note.read": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.queue": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.rule": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.rule.group": { + "added": [], + "category": "geändert", + "changed": { + "model": [ + "type: Many2One -> Char", + "relation: ir.model -> None" + ], + "name": [ + "required: None -> True" + ] + }, + "removed": [] + }, + "ir.rule.group-res.group": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.sequence": { + "added": [ + "preview", + "sequence_type" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "code", + "groups" + ] + }, + "ir.sequence.strict": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.sequence.type": { + "added": [], + "category": "geändert", + "changed": {}, + "removed": [ + "code" + ] + }, + "ir.sequence.type-res.group": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.session": { + "added": [ + "ip_address" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "ir.session.wizard": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation": { + "added": [ + "field", + "src_plural", + "value_1", + "value_2", + "value_3" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "src_md5" + ] + }, + "ir.translation.clean": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.clean.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.clean.succeed": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.export": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.export.result": { + "added": [ + "filename", + "language", + "module" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "ir.translation.export.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.report": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.set": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.set.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.set.succeed": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.update": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.translation.update.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.trigger": { + "added": [ + "action", + "on_create_", + "on_delete_", + "on_time_", + "on_write_" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "action_function", + "action_model", + "on_create", + "on_delete", + "on_time", + "on_write" + ] + }, + "ir.trigger.log": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.ui.icon": { + "added": [], + "category": "geändert", + "changed": { + "icon": [ + "type: Function[Char] -> Function[Text]" + ] + }, + "removed": [ + "sequence" + ] + }, + "ir.ui.menu": { + "added": [ + "favorites" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "ir.ui.menu-res.group": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.ui.menu.favorite": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.ui.view": { + "added": [ + "basis", + "extensions" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "priority" + ] + }, + "ir.ui.view.show": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.ui.view.show.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.ui.view_search": { + "added": [], + "category": "geändert", + "changed": { + "user": [ + "required: True -> None" + ] + }, + "removed": [] + }, + "ir.ui.view_tree_optional": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "ir.ui.view_tree_state": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "ir.ui.view_tree_width": { + "added": [ + "occurrence", + "screen_width" + ], + "category": "geändert", + "changed": { + "width": [ + "required: True -> None" + ] + }, + "removed": [] + }, + "party.address": { + "added": [ + "attn", + "building_name", + "building_number", + "contact_mechanisms", + "floor_number", + "identifiers", + "post_box", + "post_office", + "postal_code", + "private_bag", + "room_number", + "street_name", + "street_single_line", + "street_unstructured", + "subdivision_types", + "unit_number", + "warehouses" + ], + "category": "geändert", + "changed": { + "street": [ + "type: Text -> Function[Text]" + ] + }, + "removed": [ + "name", + "zip" + ] + }, + "party.address.format": { + "added": [ + "building_number_format", + "country_code", + "floor_number_format", + "language_code", + "post_box_format", + "post_office_format", + "private_bag_format", + "room_number_format", + "street_format", + "unit_number_format" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "country", + "language" + ] + }, + "party.address.subdivision_type": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "party.category": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.check_vies": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.check_vies.result": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.configuration": { + "added": [ + "identifier_types" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "party.configuration.party_lang": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.configuration.party_sequence": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.contact_mechanism": { + "added": [ + "address", + "delivery", + "language", + "languages" + ], + "category": "geändert", + "changed": { + "value": [ + "required: None -> True" + ] + }, + "removed": [] + }, + "party.contact_mechanism.language": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "party.erase": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.erase.ask": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.identifier": { + "added": [ + "address", + "code_compact", + "type_address" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "party.letter": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.party": { + "added": [ + "code_alnum", + "code_digit", + "delivered_to_warehouses", + "distance" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "party.party-delivered_to-stock.location": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "party.party-party.category": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.party.lang": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.party.location": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.replace": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "party.replace.ask": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.by_location.context": { + "added": [ + "company" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "product.category": { + "added": [ + "code", + "code_readonly", + "templates" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "product.configuration": { + "added": [ + "category_sequence", + "default_lot_sequence", + "product_sequence", + "template_sequence" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "product.configuration.default_cost_price_method": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.configuration.default_lot_sequence": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.cost_price": { + "added": [], + "category": "geändert", + "changed": { + "cost_price": [ + "required: None -> True" + ] + }, + "removed": [] + }, + "product.cost_price.revision": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.cost_price_method": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.identifier": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.list_price": { + "added": [ + "product" + ], + "category": "geändert", + "changed": { + "template": [ + "required: None -> True" + ] + }, + "removed": [] + }, + "product.modify_cost_price": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.modify_cost_price.start": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.price_list": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.price_list.line": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.product": { + "added": [ + "code_readonly", + "identifiers", + "list_price", + "list_price_used", + "list_prices", + "position", + "prefix_code", + "production_lead_times", + "replaced_by", + "suffix_code" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "lead_times" + ] + }, + "product.product-production.bom": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.product.replace": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.product.replace.ask": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.recompute_cost_price": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.recompute_cost_price.start": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "product.template": { + "added": [ + "code", + "code_readonly", + "locations", + "lot_sequence" + ], + "category": "geändert", + "changed": { + "lot_required": [ + "type: Many2Many -> MultiSelection", + "relation: product.template-stock.lot.type -> None" + ] + }, + "removed": [ + "height_digits", + "length_digits", + "volume_digits", + "weight_digits", + "width_digits" + ] + }, + "product.template-product.category": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.template-product.category.all": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.template-stock.lot.type": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "product.uom": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "product.uom.category": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "production": { + "added": [ + "origin", + "type", + "unit" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "effective_date", + "planned_date", + "reference", + "unit_digits", + "uom" + ] + }, + "production.assign": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "production.assign.failed": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "production.bom": { + "added": [ + "code", + "code_readonly", + "input_products", + "phantom", + "phantom_quantity", + "phantom_unit" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "production.bom.input": { + "added": [ + "phantom_bom", + "unit" + ], + "category": "geändert", + "changed": { + "product": [ + "required: True -> None" + ] + }, + "removed": [ + "unit_digits", + "uom" + ] + }, + "production.bom.output": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "production.bom.tree": { + "added": [ + "unit" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "unit_digits", + "uom" + ] + }, + "production.bom.tree.open": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "production.bom.tree.open.start": { + "added": [ + "unit" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "unit_digits", + "uom" + ] + }, + "production.bom.tree.open.tree": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "production.configuration": { + "added": [ + "bom_sequence" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "production.configuration.production_sequence": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "production.lead_time": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "production.split": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "production.split.start": { + "added": [ + "unit" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "unit_digits", + "uom" + ] + }, + "res.group": { + "added": [ + "parent" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "res.notification": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "res.user": { + "added": [ + "avatar_badge_url", + "company_filter", + "notifications", + "warehouse" + ], + "category": "geändert", + "changed": { + "companies": [ + "type: Function[One2Many] -> Many2Many", + "relation: None -> res.user-company.company" + ], + "menu": [ + "required: True -> None" + ] + }, + "removed": [ + "main_company" + ] + }, + "res.user-company.company": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "res.user-company.employee": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "res.user-ir.action": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "res.user-res.group": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "res.user.application": { + "added": [], + "category": "geändert", + "changed": { + "application": [ + "required: None -> True" + ] + }, + "removed": [] + }, + "res.user.config": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "res.user.config.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "res.user.device": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "res.user.email_reset_password": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "res.user.login.attempt": { + "added": [ + "device_cookie" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "res.user.warning": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.configuration": { + "added": [ + "measurement_volume_uom", + "measurement_weight_uom" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "stock.configuration.location": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.configuration.measurement": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.configuration.sequence": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.inventory": { + "added": [], + "category": "geändert", + "changed": {}, + "removed": [ + "lost_found" + ] + }, + "stock.inventory.count": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.inventory.count.quantity": { + "added": [ + "lot", + "quantity", + "total_quantity", + "unit" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "quantity_added", + "quantity_resulting", + "unit_digits", + "uom" + ] + }, + "stock.inventory.count.search": { + "added": [], + "category": "geändert", + "changed": {}, + "removed": [ + "search_model" + ] + }, + "stock.inventory.line": { + "added": [ + "inventory_date", + "inventory_location", + "unit" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "unit_digits", + "uom" + ] + }, + "stock.location": { + "added": [ + "allow_pickup", + "lost_found_location", + "production_output_location", + "production_picking_location", + "quantity_uom", + "waste_locations", + "waste_warehouses" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "stock.location.lead_time": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.location.lot.shelf_life": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.location.waste": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.lot": { + "added": [ + "default_uom" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "expiration_date", + "expiration_state", + "number", + "product", + "shelf_life_expiration_date", + "shelf_life_expiration_state" + ] + }, + "stock.lot.trace": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.lot.type": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "stock.lots_by_location.context": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.lots_by_locations": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.move": { + "added": [ + "cost_price_required", + "delay", + "from_location_name", + "origin_planned_date", + "outcome_moves", + "product_cost_price", + "production", + "production_cost_price_updated", + "to_location_name", + "unit", + "unit_price_company", + "unit_price_updated" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "unit_digits", + "uom" + ] + }, + "stock.move.add.lots": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.move.add.lots.start": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.move.add.lots.start.lot": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.move.split": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.move.split.start": { + "added": [ + "unit" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "unit_digits", + "uom" + ] + }, + "stock.package": { + "added": [ + "additional_weight_uom" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "stock.period": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.period.cache": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.period.cache.lot": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.product.location": { + "added": [ + "template" + ], + "category": "geändert", + "changed": { + "product": [ + "required: True -> None" + ] + }, + "removed": [] + }, + "stock.product_quantities_warehouse": { + "added": [ + "company", + "product" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "stock.product_quantities_warehouse.context": { + "added": [ + "company", + "stock_skip_warehouse" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "stock.product_quantities_warehouse.move": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.product_quantities_warehouse.move.open": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.product_quantities_warehouse.open": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.products_by_locations": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.products_by_locations.context": { + "added": [ + "company" + ], + "category": "nur ergänzt", + "changed": {}, + "removed": [] + }, + "stock.reporting.inventory": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.inventory.context": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.inventory.daily": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.inventory.move": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.inventory.range.context": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.inventory.turnover": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.inventory.turnover.context": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.category": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.category.time_series": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.category.tree": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.context": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.main": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.main.time_series": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.product": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.reporting.margin.product.time_series": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.shipment.assign": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.shipment.assign.partial": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.shipment.drop": { + "added": [], + "category": "neu", + "changed": {}, + "removed": [] + }, + "stock.shipment.in": { + "added": [], + "category": "geändert", + "changed": { + "warehouse_input": [ + "type: Function[Many2One] -> Many2One", + "relation: None -> stock.location", + "required: None -> True" + ], + "warehouse_storage": [ + "type: Function[Many2One] -> Many2One", + "relation: None -> stock.location", + "required: None -> True" + ] + }, + "removed": [ + "effective_date", + "number", + "planned_date", + "reference" + ] + }, + "stock.shipment.in.restocking_list": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.shipment.in.return": { + "added": [ + "warehouse" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "effective_date", + "number", + "planned_date", + "reference" + ] + }, + "stock.shipment.in.return.assign": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "stock.shipment.in.return.assign.failed": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "stock.shipment.internal": { + "added": [ + "internal_transit_location", + "to_warehouse", + "warehouse" + ], + "category": "geändert", + "changed": {}, + "removed": [ + "effective_date", + "number", + "planned_date", + "reference" + ] + }, + "stock.shipment.internal.assign": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "stock.shipment.internal.assign.failed": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "stock.shipment.internal.report": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.shipment.out": { + "added": [], + "category": "geändert", + "changed": { + "warehouse_output": [ + "type: Function[Many2One] -> Many2One", + "relation: None -> stock.location", + "required: None -> True" + ], + "warehouse_storage": [ + "type: Function[Many2One] -> Many2One", + "relation: None -> stock.location", + "required: None -> True" + ] + }, + "removed": [ + "effective_date", + "number", + "planned_date", + "reference" + ] + }, + "stock.shipment.out.assign": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "stock.shipment.out.assign.failed": { + "added": [], + "category": "entfernt", + "changed": {}, + "removed": [] + }, + "stock.shipment.out.delivery_note": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.shipment.out.picking_list": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.shipment.out.return": { + "added": [ + "contact_address" + ], + "category": "geändert", + "changed": { + "warehouse_input": [ + "type: Function[Many2One] -> Many2One", + "relation: None -> stock.location", + "required: None -> True" + ], + "warehouse_storage": [ + "type: Function[Many2One] -> Many2One", + "relation: None -> stock.location", + "required: None -> True" + ] + }, + "removed": [ + "delivery_address", + "effective_date", + "number", + "planned_date", + "reference" + ] + }, + "stock.shipment.out.return.restocking_list": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.shipment.split": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + }, + "stock.shipment.split.start": { + "added": [], + "category": "unverändert", + "changed": {}, + "removed": [] + } +} \ No newline at end of file diff --git a/reports/model_diff.md b/reports/model_diff.md new file mode 100644 index 0000000..4408e14 --- /dev/null +++ b/reports/model_diff.md @@ -0,0 +1,463 @@ +# Modellbaum-Diff: 5.0 -> 8.0 + + +## entfernt (12) - Modell existiert nicht mehr + +- `country.zip` +- `ir.model.field-res.group` +- `product.template-stock.lot.type` +- `production.assign` +- `production.assign.failed` +- `stock.lot.type` +- `stock.shipment.in.return.assign` +- `stock.shipment.in.return.assign.failed` +- `stock.shipment.internal.assign` +- `stock.shipment.internal.assign.failed` +- `stock.shipment.out.assign` +- `stock.shipment.out.assign.failed` + +## geändert (57) - Feld(er) entfernt oder geändert - Kandidat für einen echten Vergleichslauf + + +### `company.company` +- entfernte Felder: childs, parent +- (zusätzlich neue Felder: logo, logo_cache, tax_identifiers) + +### `country.subdivision` +- **code**: required: True -> None +- **type**: required: True -> None +- (zusätzlich neue Felder: flag) + +### `currency.currency` +- **symbol**: required: True -> None + +### `currency.currency.rate` +- **currency**: required: None -> True +- **rate**: required: None -> True + +### `ir.action` +- **type**: type: Char -> Selection +- (zusätzlich neue Felder: action, records) + +### `ir.action.act_window` +- entfernte Felder: action +- **domains**: type: Function[Binary] -> Function[Field] +- **views**: type: Function[Binary] -> Function[Field] + +### `ir.action.act_window.domain` +- entfernte Felder: sequence + +### `ir.action.act_window.view` +- entfernte Felder: sequence +- **act_window**: required: None -> True +- (zusätzlich neue Felder: model) + +### `ir.action.keyword` +- **action**: required: None -> True +- **groups**: type: Function[One2Many] -> Function[Many2Many] + +### `ir.action.report` +- entfernte Felder: action, email, pyson_email +- (zusätzlich neue Felder: record_name, report_content_html) + +### `ir.action.url` +- entfernte Felder: action + +### `ir.action.wizard` +- entfernte Felder: action, email + +### `ir.cron` +- entfernte Felder: args, function, model, name, number_calls, repeat_missed, request_user, user +- **interval_type**: required: None -> True +- **next_call**: required: True -> None +- (zusätzlich neue Felder: day, hour, logs, method, minute, running, timezone, weekday) + +### `ir.model` +- entfernte Felder: info, model +- **fields**: required: True -> None +- **name**: required: None -> True +- (zusätzlich neue Felder: string) + +### `ir.model.access` +- **model**: type: Many2One -> Char; relation: ir.model -> None + +### `ir.model.button` +- **model**: type: Many2One -> Char; relation: ir.model -> None + +### `ir.model.data` +- entfernte Felder: fs_values, out_of_sync, values +- **db_id**: required: True -> None +- (zusätzlich neue Felder: field_names) + +### `ir.model.field` +- entfernte Felder: field_description, groups +- **model**: type: Many2One -> Char; relation: ir.model -> None +- (zusätzlich neue Felder: access, string) + +### `ir.model.field.access` +- **field**: type: Many2One -> Char; relation: ir.model.field -> None +- (zusätzlich neue Felder: model) + +### `ir.module` +- **childs**: type: Function[One2Many] -> Function[Many2Many] +- **parents**: type: Function[One2Many] -> Function[Many2Many] + +### `ir.module.config_wizard.item` +- entfernte Felder: sequence + +### `ir.rule.group` +- **model**: type: Many2One -> Char; relation: ir.model -> None +- **name**: required: None -> True + +### `ir.sequence` +- entfernte Felder: code, groups +- (zusätzlich neue Felder: preview, sequence_type) + +### `ir.sequence.type` +- entfernte Felder: code + +### `ir.translation` +- entfernte Felder: src_md5 +- (zusätzlich neue Felder: field, src_plural, value_1, value_2, value_3) + +### `ir.trigger` +- entfernte Felder: action_function, action_model, on_create, on_delete, on_time, on_write +- (zusätzlich neue Felder: action, on_create_, on_delete_, on_time_, on_write_) + +### `ir.ui.icon` +- entfernte Felder: sequence +- **icon**: type: Function[Char] -> Function[Text] + +### `ir.ui.view` +- entfernte Felder: priority +- (zusätzlich neue Felder: basis, extensions) + +### `ir.ui.view_search` +- **user**: required: True -> None + +### `ir.ui.view_tree_width` +- **width**: required: True -> None +- (zusätzlich neue Felder: occurrence, screen_width) + +### `party.address` +- entfernte Felder: name, zip +- **street**: type: Text -> Function[Text] +- (zusätzlich neue Felder: attn, building_name, building_number, contact_mechanisms, floor_number, identifiers, post_box, post_office, postal_code, private_bag, room_number, street_name, street_single_line, street_unstructured, subdivision_types, unit_number, warehouses) + +### `party.address.format` +- entfernte Felder: country, language +- (zusätzlich neue Felder: building_number_format, country_code, floor_number_format, language_code, post_box_format, post_office_format, private_bag_format, room_number_format, street_format, unit_number_format) + +### `party.contact_mechanism` +- **value**: required: None -> True +- (zusätzlich neue Felder: address, delivery, language, languages) + +### `product.cost_price` +- **cost_price**: required: None -> True + +### `product.list_price` +- **template**: required: None -> True +- (zusätzlich neue Felder: product) + +### `product.product` +- entfernte Felder: lead_times +- (zusätzlich neue Felder: code_readonly, identifiers, list_price, list_price_used, list_prices, position, prefix_code, production_lead_times, replaced_by, suffix_code) + +### `product.template` +- entfernte Felder: height_digits, length_digits, volume_digits, weight_digits, width_digits +- **lot_required**: type: Many2Many -> MultiSelection; relation: product.template-stock.lot.type -> None +- (zusätzlich neue Felder: code, code_readonly, locations, lot_sequence) + +### `production` +- entfernte Felder: effective_date, planned_date, reference, unit_digits, uom +- (zusätzlich neue Felder: origin, type, unit) + +### `production.bom.input` +- entfernte Felder: unit_digits, uom +- **product**: required: True -> None +- (zusätzlich neue Felder: phantom_bom, unit) + +### `production.bom.tree` +- entfernte Felder: unit_digits, uom +- (zusätzlich neue Felder: unit) + +### `production.bom.tree.open.start` +- entfernte Felder: unit_digits, uom +- (zusätzlich neue Felder: unit) + +### `production.split.start` +- entfernte Felder: unit_digits, uom +- (zusätzlich neue Felder: unit) + +### `res.user` +- entfernte Felder: main_company +- **companies**: type: Function[One2Many] -> Many2Many; relation: None -> res.user-company.company +- **menu**: required: True -> None +- (zusätzlich neue Felder: avatar_badge_url, company_filter, notifications, warehouse) + +### `res.user.application` +- **application**: required: None -> True + +### `stock.inventory` +- entfernte Felder: lost_found + +### `stock.inventory.count.quantity` +- entfernte Felder: quantity_added, quantity_resulting, unit_digits, uom +- (zusätzlich neue Felder: lot, quantity, total_quantity, unit) + +### `stock.inventory.count.search` +- entfernte Felder: search_model + +### `stock.inventory.line` +- entfernte Felder: unit_digits, uom +- (zusätzlich neue Felder: inventory_date, inventory_location, unit) + +### `stock.lot` +- entfernte Felder: expiration_date, expiration_state, number, product, shelf_life_expiration_date, shelf_life_expiration_state +- (zusätzlich neue Felder: default_uom) + +### `stock.move` +- entfernte Felder: unit_digits, uom +- (zusätzlich neue Felder: cost_price_required, delay, from_location_name, origin_planned_date, outcome_moves, product_cost_price, production, production_cost_price_updated, to_location_name, unit, unit_price_company, unit_price_updated) + +### `stock.move.split.start` +- entfernte Felder: unit_digits, uom +- (zusätzlich neue Felder: unit) + +### `stock.product.location` +- **product**: required: True -> None +- (zusätzlich neue Felder: template) + +### `stock.shipment.in` +- entfernte Felder: effective_date, number, planned_date, reference +- **warehouse_input**: type: Function[Many2One] -> Many2One; relation: None -> stock.location; required: None -> True +- **warehouse_storage**: type: Function[Many2One] -> Many2One; relation: None -> stock.location; required: None -> True + +### `stock.shipment.in.return` +- entfernte Felder: effective_date, number, planned_date, reference +- (zusätzlich neue Felder: warehouse) + +### `stock.shipment.internal` +- entfernte Felder: effective_date, number, planned_date, reference +- (zusätzlich neue Felder: internal_transit_location, to_warehouse, warehouse) + +### `stock.shipment.out` +- entfernte Felder: effective_date, number, planned_date, reference +- **warehouse_output**: type: Function[Many2One] -> Many2One; relation: None -> stock.location; required: None -> True +- **warehouse_storage**: type: Function[Many2One] -> Many2One; relation: None -> stock.location; required: None -> True + +### `stock.shipment.out.return` +- entfernte Felder: delivery_address, effective_date, number, planned_date, reference +- **warehouse_input**: type: Function[Many2One] -> Many2One; relation: None -> stock.location; required: None -> True +- **warehouse_storage**: type: Function[Many2One] -> Many2One; relation: None -> stock.location; required: None -> True +- (zusätzlich neue Felder: contact_address) + +## neu (76) - Modell gibt es erst ab 8.0 + +- `company.company.logo.cache` +- `company.company.tax_identifier` +- `country.organization` +- `country.organization.member` +- `country.postal_code` +- `country.region` +- `currency.cron` +- `currency.cron-currency.currency` +- `ir.avatar` +- `ir.avatar.cache` +- `ir.calendar.day` +- `ir.calendar.month` +- `ir.chat.channel` +- `ir.chat.follower` +- `ir.chat.message` +- `ir.cron.log` +- `ir.email` +- `ir.email.address` +- `ir.email.template` +- `ir.email.template-ir.action.report` +- `ir.error` +- `ir.export-res.group` +- `ir.export-write-res.group` +- `ir.filestore.queue` +- `ir.lang.config` +- `ir.lang.config.start` +- `ir.message` +- `ir.model.log` +- `ir.model.refresh_materialized` +- `ir.module.config.start` +- `ir.ui.view_tree_optional` +- `party.address.subdivision_type` +- `party.contact_mechanism.language` +- `party.party-delivered_to-stock.location` +- `product.configuration.default_lot_sequence` +- `product.cost_price.revision` +- `product.identifier` +- `product.modify_cost_price` +- `product.modify_cost_price.start` +- `product.price_list` +- `product.price_list.line` +- `product.product.replace` +- `product.product.replace.ask` +- `product.recompute_cost_price.start` +- `res.notification` +- `res.user-company.company` +- `res.user.device` +- `stock.configuration.measurement` +- `stock.location.waste` +- `stock.lot.trace` +- `stock.lots_by_locations` +- `stock.move.add.lots` +- `stock.move.add.lots.start` +- `stock.move.add.lots.start.lot` +- `stock.product_quantities_warehouse.move` +- `stock.product_quantities_warehouse.move.open` +- `stock.product_quantities_warehouse.open` +- `stock.products_by_locations` +- `stock.reporting.inventory` +- `stock.reporting.inventory.context` +- `stock.reporting.inventory.daily` +- `stock.reporting.inventory.move` +- `stock.reporting.inventory.range.context` +- `stock.reporting.inventory.turnover` +- `stock.reporting.inventory.turnover.context` +- `stock.reporting.margin.category` +- `stock.reporting.margin.category.time_series` +- `stock.reporting.margin.category.tree` +- `stock.reporting.margin.context` +- `stock.reporting.margin.main` +- `stock.reporting.margin.main.time_series` +- `stock.reporting.margin.product` +- `stock.reporting.margin.product.time_series` +- `stock.shipment.assign` +- `stock.shipment.assign.partial` +- `stock.shipment.drop` + +## nur ergänzt (24) - nur neue Felder dazugekommen, Rest unverändert + +- `company.employee` +- `country.country` +- `ir.configuration` +- `ir.export` +- `ir.lang` +- `ir.session` +- `ir.translation.export.result` +- `ir.ui.menu` +- `party.configuration` +- `party.identifier` +- `party.party` +- `product.by_location.context` +- `product.category` +- `product.configuration` +- `production.bom` +- `production.configuration` +- `res.group` +- `res.user.login.attempt` +- `stock.configuration` +- `stock.location` +- `stock.package` +- `stock.product_quantities_warehouse` +- `stock.product_quantities_warehouse.context` +- `stock.products_by_locations.context` + +## unverändert (101) - komplett identisch geblieben + +- `company.company.config` +- `company.company.config.start` +- `ir.action-res.group` +- `ir.attachment` +- `ir.cache` +- `ir.cron-company.company` +- `ir.date` +- `ir.export.line` +- `ir.model.button-button.reset` +- `ir.model.button-res.group` +- `ir.model.button.click` +- `ir.model.button.rule` +- `ir.model.graph` +- `ir.model.print_model_graph` +- `ir.model.print_model_graph.start` +- `ir.model.workflow_graph` +- `ir.module.activate_upgrade` +- `ir.module.activate_upgrade.done` +- `ir.module.activate_upgrade.start` +- `ir.module.config` +- `ir.module.config_wizard` +- `ir.module.config_wizard.done` +- `ir.module.config_wizard.first` +- `ir.module.config_wizard.other` +- `ir.module.dependency` +- `ir.note` +- `ir.note.read` +- `ir.queue` +- `ir.rule` +- `ir.rule.group-res.group` +- `ir.sequence.strict` +- `ir.sequence.type-res.group` +- `ir.session.wizard` +- `ir.translation.clean` +- `ir.translation.clean.start` +- `ir.translation.clean.succeed` +- `ir.translation.export` +- `ir.translation.export.start` +- `ir.translation.report` +- `ir.translation.set` +- `ir.translation.set.start` +- `ir.translation.set.succeed` +- `ir.translation.update` +- `ir.translation.update.start` +- `ir.trigger.log` +- `ir.ui.menu-res.group` +- `ir.ui.menu.favorite` +- `ir.ui.view.show` +- `ir.ui.view.show.start` +- `ir.ui.view_tree_state` +- `party.category` +- `party.check_vies` +- `party.check_vies.result` +- `party.configuration.party_lang` +- `party.configuration.party_sequence` +- `party.erase` +- `party.erase.ask` +- `party.letter` +- `party.party-party.category` +- `party.party.lang` +- `party.party.location` +- `party.replace` +- `party.replace.ask` +- `product.configuration.default_cost_price_method` +- `product.cost_price_method` +- `product.product-production.bom` +- `product.recompute_cost_price` +- `product.template-product.category` +- `product.template-product.category.all` +- `product.uom` +- `product.uom.category` +- `production.bom.output` +- `production.bom.tree.open` +- `production.bom.tree.open.tree` +- `production.configuration.production_sequence` +- `production.lead_time` +- `production.split` +- `res.user-company.employee` +- `res.user-ir.action` +- `res.user-res.group` +- `res.user.config` +- `res.user.config.start` +- `res.user.email_reset_password` +- `res.user.warning` +- `stock.configuration.location` +- `stock.configuration.sequence` +- `stock.inventory.count` +- `stock.location.lead_time` +- `stock.location.lot.shelf_life` +- `stock.lots_by_location.context` +- `stock.move.split` +- `stock.period` +- `stock.period.cache` +- `stock.period.cache.lot` +- `stock.shipment.in.restocking_list` +- `stock.shipment.internal.report` +- `stock.shipment.out.delivery_note` +- `stock.shipment.out.picking_list` +- `stock.shipment.out.return.restocking_list` +- `stock.shipment.split` +- `stock.shipment.split.start` diff --git a/reports/model_tree_5.0.json b/reports/model_tree_5.0.json new file mode 100644 index 0000000..d783068 --- /dev/null +++ b/reports/model_tree_5.0.json @@ -0,0 +1,7192 @@ +{ + "company.company": { + "fields": { + "childs": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": null, + "settable": true, + "type": "One2Many" + }, + "currency": { + "file": "company/company.py", + "module": "company", + "relation": "currency.currency", + "required": true, + "settable": true, + "type": "Many2One" + }, + "employees": { + "file": "company/company.py", + "module": "company", + "relation": "company.employee", + "required": null, + "settable": true, + "type": "One2Many" + }, + "footer": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "header": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "parent": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "party": { + "file": "company/company.py", + "module": "company", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "timezone": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "company.company.config": { + "fields": {}, + "persisted": false + }, + "company.company.config.start": { + "fields": {}, + "persisted": false + }, + "company.employee": { + "fields": { + "company": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "end_date": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "party": { + "file": "company/company.py", + "module": "company", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "start_date": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + } + }, + "persisted": true + }, + "country.country": { + "fields": { + "code": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code3": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code_numeric": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "subdivisions": { + "file": "country/country.py", + "module": "country", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "country.subdivision": { + "fields": { + "code": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "country": { + "file": "country/country.py", + "module": "country", + "relation": "country.country", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "country/country.py", + "module": "country", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "country.zip": { + "fields": { + "city": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "country": { + "file": "country/country.py", + "module": "country", + "relation": "country.country", + "required": true, + "settable": true, + "type": "Many2One" + }, + "subdivision": { + "file": "country/country.py", + "module": "country", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "Many2One" + }, + "zip": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "currency.currency": { + "fields": { + "code": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "digits": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "name": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "numeric_code": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "rate": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "rates": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.currency.rate", + "required": null, + "settable": true, + "type": "One2Many" + }, + "rounding": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Numeric" + }, + "symbol": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "currency.currency.rate": { + "fields": { + "currency": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.currency", + "required": null, + "settable": true, + "type": "Many2One" + }, + "date": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "rate": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + } + }, + "persisted": true + }, + "ir.action": { + "fields": { + "groups": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "icon": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.ui.icon", + "required": null, + "settable": true, + "type": "Many2One" + }, + "keywords": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.keyword", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "type": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "usage": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.action-res.group": { + "fields": { + "action": { + "file": "res/ir.py", + "module": "res", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "group": { + "file": "res/ir.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.action.act_window": { + "fields": { + "act_window_domains": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window.domain", + "required": null, + "settable": true, + "type": "One2Many" + }, + "act_window_views": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window.view", + "required": null, + "settable": true, + "type": "One2Many" + }, + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "context": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "context_domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "context_model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "domains": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Binary]" + }, + "limit": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "order": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "pyson_context": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "pyson_domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "pyson_order": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "pyson_search_value": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "res_model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "search_value": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "views": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Binary]" + } + }, + "persisted": true + }, + "ir.action.act_window.domain": { + "fields": { + "act_window": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window", + "required": true, + "settable": true, + "type": "Many2One" + }, + "count": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "sequence": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "ir.action.act_window.view": { + "fields": { + "act_window": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window", + "required": null, + "settable": true, + "type": "Many2One" + }, + "sequence": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "view": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.ui.view", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.action.keyword": { + "fields": { + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action", + "required": null, + "settable": true, + "type": "Many2One" + }, + "groups": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[One2Many]" + }, + "keyword": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "model": { + "file": "ir/action.py", + "module": "ir", + "relation": "Model", + "required": null, + "settable": true, + "type": "Reference" + } + }, + "persisted": true + }, + "ir.action.report": { + "fields": { + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "direct_print": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "email": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "extension": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "is_custom": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "pyson_email": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "report": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "report_content": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Binary]" + }, + "report_content_custom": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Binary" + }, + "report_content_name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "report_name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "single": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "template_extension": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "translatable": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.action.url": { + "fields": { + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "url": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.action.wizard": { + "fields": { + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "email": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "window": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "wiz_name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.attachment": { + "fields": { + "data": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Binary" + }, + "data_size": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "description": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "file_id": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "link": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "summary": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "type": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.cache": { + "fields": { + "name": { + "file": "ir/cache.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "timestamp": { + "file": "ir/cache.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + } + }, + "persisted": true + }, + "ir.configuration": { + "fields": { + "hostname": { + "file": "ir/configuration.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "language": { + "file": "ir/configuration.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.cron": { + "fields": { + "args": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "companies": { + "file": "company/cron.py", + "module": "company", + "relation": "ir.cron-company.company", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "function": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "interval_number": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "interval_type": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "model": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "next_call": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "DateTime" + }, + "number_calls": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "repeat_missed": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "request_user": { + "file": "ir/cron.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "ir/cron.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.cron-company.company": { + "fields": { + "company": { + "file": "company/cron.py", + "module": "company", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "cron": { + "file": "company/cron.py", + "module": "company", + "relation": "ir.cron", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.date": { + "fields": {}, + "persisted": false + }, + "ir.export": { + "fields": { + "export_fields": { + "file": "ir/export.py", + "module": "ir", + "relation": "ir.export.line", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "resource": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.export.line": { + "fields": { + "export": { + "file": "ir/export.py", + "module": "ir", + "relation": "ir.export", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.lang": { + "fields": { + "code": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "date": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "decimal_point": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "direction": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "grouping": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "mon_decimal_point": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "mon_grouping": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "mon_thousands_sep": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "n_cs_precedes": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "n_sep_by_space": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "n_sign_posn": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "name": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "negative_sign": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "p_cs_precedes": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "p_sep_by_space": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "p_sign_posn": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "parent": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "positive_sign": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "thousands_sep": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "translatable": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.model": { + "fields": { + "fields": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.field", + "required": true, + "settable": true, + "type": "One2Many" + }, + "global_search_p": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "info": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.model.access": { + "fields": { + "description": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "group": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.group", + "required": null, + "settable": true, + "type": "Many2One" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "perm_create": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_delete": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_read": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_write": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.model.button": { + "fields": { + "clicks": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button.click", + "required": null, + "settable": true, + "type": "One2Many" + }, + "confirm": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "groups": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "help": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "reset": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button-button.reset", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "reset_by": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button-button.reset", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "rules": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button.rule", + "required": null, + "settable": true, + "type": "One2Many" + }, + "string": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.model.button-button.reset": { + "fields": { + "button": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "button_ruled": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.button-res.group": { + "fields": { + "button": { + "file": "res/ir.py", + "module": "res", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "group": { + "file": "res/ir.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.button.click": { + "fields": { + "button": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "record_id": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "user": { + "file": "res/ir.py", + "module": "res", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.button.rule": { + "fields": { + "button": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "condition": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "description": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "group": { + "file": "res/ir.py", + "module": "res", + "relation": "res.group", + "required": null, + "settable": true, + "type": "Many2One" + }, + "number_user": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "ir.model.data": { + "fields": { + "db_id": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "fs_id": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "fs_values": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "noupdate": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "out_of_sync": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "values": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": true + }, + "ir.model.field": { + "fields": { + "field_description": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "groups": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.field-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "help": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "module": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "relation": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "ttype": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.model.field-res.group": { + "fields": { + "field": { + "file": "res/ir.py", + "module": "res", + "relation": "ir.model.field", + "required": true, + "settable": true, + "type": "Many2One" + }, + "group": { + "file": "res/ir.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.field.access": { + "fields": { + "description": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "field": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.field", + "required": true, + "settable": true, + "type": "Many2One" + }, + "group": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.group", + "required": null, + "settable": true, + "type": "Many2One" + }, + "perm_create": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_delete": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_read": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_write": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.model.graph": { + "fields": {}, + "persisted": false + }, + "ir.model.print_model_graph": { + "fields": {}, + "persisted": false + }, + "ir.model.print_model_graph.start": { + "fields": { + "filter": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "level": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": false + }, + "ir.model.workflow_graph": { + "fields": {}, + "persisted": false + }, + "ir.module": { + "fields": { + "childs": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[One2Many]" + }, + "dependencies": { + "file": "ir/module.py", + "module": "ir", + "relation": "ir.module.dependency", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parents": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[One2Many]" + }, + "state": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "version": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "ir.module.activate_upgrade": { + "fields": {}, + "persisted": false + }, + "ir.module.activate_upgrade.done": { + "fields": {}, + "persisted": false + }, + "ir.module.activate_upgrade.start": { + "fields": { + "module_info": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": false + }, + "ir.module.config": { + "fields": {}, + "persisted": false + }, + "ir.module.config_wizard": { + "fields": {}, + "persisted": false + }, + "ir.module.config_wizard.done": { + "fields": {}, + "persisted": false + }, + "ir.module.config_wizard.first": { + "fields": {}, + "persisted": false + }, + "ir.module.config_wizard.item": { + "fields": { + "action": { + "file": "ir/module.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "sequence": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "state": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.module.config_wizard.other": { + "fields": { + "percentage": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + } + }, + "persisted": false + }, + "ir.module.dependency": { + "fields": { + "module": { + "file": "ir/module.py", + "module": "ir", + "relation": "ir.module", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + } + }, + "persisted": true + }, + "ir.note": { + "fields": { + "message": { + "file": "ir/note.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "message_wrapped": { + "file": "ir/note.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Text]" + }, + "unread": { + "file": "ir/note.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Boolean]" + } + }, + "persisted": true + }, + "ir.note.read": { + "fields": { + "note": { + "file": "ir/note.py", + "module": "ir", + "relation": "ir.note", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "ir/note.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.queue": { + "fields": { + "data": { + "file": "ir/queue.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Dict" + }, + "dequeued_at": { + "file": "ir/queue.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "enqueued_at": { + "file": "ir/queue.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Timestamp" + }, + "expected_at": { + "file": "ir/queue.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "finished_at": { + "file": "ir/queue.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "name": { + "file": "ir/queue.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "scheduled_at": { + "file": "ir/queue.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + } + }, + "persisted": true + }, + "ir.rule": { + "fields": { + "domain": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "rule_group": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.rule.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.rule.group": { + "fields": { + "default_p": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "global_p": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "groups": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.rule.group-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "model": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "perm_create": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_delete": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_read": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_write": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "rules": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.rule", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "ir.rule.group-res.group": { + "fields": { + "group": { + "file": "res/ir.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "rule_group": { + "file": "res/ir.py", + "module": "res", + "relation": "ir.rule.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.sequence": { + "fields": { + "code": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "company": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "groups": { + "file": "res/ir.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2Many]" + }, + "last_timestamp": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "name": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "number_increment": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "number_next": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function" + }, + "number_next_internal": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "padding": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "prefix": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "suffix": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "timestamp_offset": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "timestamp_rounding": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "type": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.sequence.strict": { + "fields": {}, + "persisted": false + }, + "ir.sequence.type": { + "fields": { + "code": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "groups": { + "file": "res/ir.py", + "module": "res", + "relation": "ir.sequence.type-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "name": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.sequence.type-res.group": { + "fields": { + "group": { + "file": "res/ir.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "sequence_type": { + "file": "res/ir.py", + "module": "res", + "relation": "ir.sequence.type", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.session": { + "fields": { + "key": { + "file": "ir/session.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.session.wizard": { + "fields": { + "data": { + "file": "ir/session.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": true + }, + "ir.translation": { + "fields": { + "fuzzy": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "lang": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "model": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "module": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "overriding_module": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "res_id": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "src": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "src_md5": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "type": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "value": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": true + }, + "ir.translation.clean": { + "fields": {}, + "persisted": false + }, + "ir.translation.clean.start": { + "fields": {}, + "persisted": false + }, + "ir.translation.clean.succeed": { + "fields": {}, + "persisted": false + }, + "ir.translation.export": { + "fields": {}, + "persisted": false + }, + "ir.translation.export.result": { + "fields": { + "file": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Binary" + } + }, + "persisted": false + }, + "ir.translation.export.start": { + "fields": { + "language": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.lang", + "required": true, + "settable": true, + "type": "Many2One" + }, + "module": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.module", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "ir.translation.report": { + "fields": {}, + "persisted": false + }, + "ir.translation.set": { + "fields": {}, + "persisted": false + }, + "ir.translation.set.start": { + "fields": {}, + "persisted": false + }, + "ir.translation.set.succeed": { + "fields": {}, + "persisted": false + }, + "ir.translation.update": { + "fields": {}, + "persisted": false + }, + "ir.translation.update.start": { + "fields": { + "language": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.lang", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "ir.trigger": { + "fields": { + "action_function": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "action_model": { + "file": "ir/trigger.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "condition": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "limit_number": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "minimum_time_delay": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "TimeDelta" + }, + "model": { + "file": "ir/trigger.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "on_create": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "on_delete": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "on_time": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "on_write": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.trigger.log": { + "fields": { + "record_id": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "trigger": { + "file": "ir/trigger.py", + "module": "ir", + "relation": "ir.trigger", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.icon": { + "fields": { + "icon": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "module": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "path": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "sequence": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "ir.ui.menu": { + "fields": { + "action": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Reference]" + }, + "action_keywords": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.action.keyword", + "required": null, + "settable": true, + "type": "One2Many" + }, + "childs": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu", + "required": null, + "settable": true, + "type": "One2Many" + }, + "complete_name": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "favorite": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "groups": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "icon": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "name": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.menu-res.group": { + "fields": { + "group": { + "file": "res/ir.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "menu": { + "file": "res/ir.py", + "module": "res", + "relation": "ir.ui.menu", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.menu.favorite": { + "fields": { + "menu": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.view": { + "fields": { + "arch": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Text]" + }, + "data": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "domain": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "field_childs": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "inherit": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "ir.ui.view", + "required": null, + "settable": true, + "type": "Many2One" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "priority": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "type": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.ui.view.show": { + "fields": {}, + "persisted": false + }, + "ir.ui.view.show.start": { + "fields": {}, + "persisted": false + }, + "ir.ui.view_search": { + "fields": { + "domain": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "user": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.view_tree_state": { + "fields": { + "child_name": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "domain": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "nodes": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "selected_nodes": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "user": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.view_tree_width": { + "fields": { + "field": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "user": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + }, + "width": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "party.address": { + "fields": { + "city": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "country": { + "file": "party/address.py", + "module": "party", + "relation": "country.country", + "required": null, + "settable": true, + "type": "Many2One" + }, + "delivery": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "full_address": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Text]" + }, + "name": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "party": { + "file": "party/address.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "party_name": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "street": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "subdivision": { + "file": "party/address.py", + "module": "party", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "Many2One" + }, + "zip": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "party.address.format": { + "fields": { + "country": { + "file": "party/address.py", + "module": "party", + "relation": "country.country", + "required": null, + "settable": true, + "type": "Many2One" + }, + "format_": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Text" + }, + "language": { + "file": "party/address.py", + "module": "party", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.category": { + "fields": { + "childs": { + "file": "party/category.py", + "module": "party", + "relation": "party.category", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "party/category.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "party/category.py", + "module": "party", + "relation": "party.category", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.check_vies": { + "fields": {}, + "persisted": false + }, + "party.check_vies.result": { + "fields": { + "parties_failed": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "parties_succeed": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "party.configuration": { + "fields": { + "party_lang": { + "file": "party/configuration.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "party_sequence": { + "file": "party/configuration.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + } + }, + "persisted": true + }, + "party.configuration.party_lang": { + "fields": {}, + "persisted": true + }, + "party.configuration.party_sequence": { + "fields": {}, + "persisted": true + }, + "party.contact_mechanism": { + "fields": { + "comment": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "email": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "name": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "other_value": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "party": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "sip": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "skype": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "type": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "url": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "value": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "value_compact": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "website": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "party.erase": { + "fields": {}, + "persisted": false + }, + "party.erase.ask": { + "fields": { + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "party.identifier": { + "fields": { + "code": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "party.letter": { + "fields": {}, + "persisted": false + }, + "party.party": { + "fields": { + "addresses": { + "file": "party/party.py", + "module": "party", + "relation": "party.address", + "required": null, + "settable": true, + "type": "One2Many" + }, + "categories": { + "file": "party/party.py", + "module": "party", + "relation": "party.party-party.category", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "code": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "code_readonly": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "contact_mechanisms": { + "file": "party/party.py", + "module": "party", + "relation": "party.contact_mechanism", + "required": null, + "settable": true, + "type": "One2Many" + }, + "customer_location": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "email": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "fax": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "full_name": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "identifiers": { + "file": "party/party.py", + "module": "party", + "relation": "party.identifier", + "required": null, + "settable": true, + "type": "One2Many" + }, + "lang": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "langs": { + "file": "party/party.py", + "module": "party", + "relation": "party.party.lang", + "required": null, + "settable": true, + "type": "One2Many" + }, + "locations": { + "file": "stock/location.py", + "module": "stock", + "relation": "party.party.location", + "required": null, + "settable": true, + "type": "One2Many" + }, + "mobile": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "name": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "phone": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "replaced_by": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2One" + }, + "supplier_location": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "tax_identifier": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "website": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "party.party-party.category": { + "fields": { + "category": { + "file": "party/party.py", + "module": "party", + "relation": "party.category", + "required": true, + "settable": true, + "type": "Many2One" + }, + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.party.lang": { + "fields": { + "lang": { + "file": "party/party.py", + "module": "party", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2One" + }, + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.party.location": { + "fields": { + "party": { + "file": "stock/location.py", + "module": "stock", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.replace": { + "fields": {}, + "persisted": false + }, + "party.replace.ask": { + "fields": { + "destination": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "source": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "product.by_location.context": { + "fields": { + "forecast_date": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "stock_date_end": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Date]" + } + }, + "persisted": false + }, + "product.category": { + "fields": { + "childs": { + "file": "product/category.py", + "module": "product", + "relation": "product.category", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "product/category.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "product/category.py", + "module": "product", + "relation": "product.category", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.configuration": { + "fields": { + "default_cost_price_method": { + "file": "product/configuration.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + } + }, + "persisted": true + }, + "product.configuration.default_cost_price_method": { + "fields": {}, + "persisted": true + }, + "product.cost_price": { + "fields": { + "cost_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "product": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.cost_price_method": { + "fields": { + "cost_price_method": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.list_price": { + "fields": { + "list_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.product": { + "fields": { + "boms": { + "file": "production/product.py", + "module": "production", + "relation": "product.product-production.bom", + "required": null, + "settable": true, + "type": "One2Many" + }, + "code": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "cost_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "cost_price_uom": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "cost_prices": { + "file": "product/product.py", + "module": "product", + "relation": "product.cost_price", + "required": null, + "settable": true, + "type": "One2Many" + }, + "cost_value": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "description": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "forecast_quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "lead_times": { + "file": "production/product.py", + "module": "production", + "relation": "production.lead_time", + "required": null, + "settable": true, + "type": "One2Many" + }, + "list_price_uom": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "locations": { + "file": "stock_product_location/product.py", + "module": "stock_product_location", + "relation": "stock.product.location", + "required": null, + "settable": true, + "type": "One2Many" + }, + "quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.product-production.bom": { + "fields": { + "bom": { + "file": "production/product.py", + "module": "production", + "relation": "production.bom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "production/product.py", + "module": "production", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.recompute_cost_price": { + "fields": {}, + "persisted": false + }, + "product.template": { + "fields": { + "categories": { + "file": "product/product.py", + "module": "product", + "relation": "product.template-product.category", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "categories_all": { + "file": "product/product.py", + "module": "product", + "relation": "product.template-product.category.all", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "consumable": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "cost_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "cost_price_method": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "cost_price_methods": { + "file": "product/product.py", + "module": "product", + "relation": "product.cost_price_method", + "required": null, + "settable": true, + "type": "One2Many" + }, + "cost_value": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "default_uom": { + "file": "product/product.py", + "module": "product", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "default_uom_category": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "expiration_state": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "expiration_time": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "forecast_quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "height": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "height_digits": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "height_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "length": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "length_digits": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "length_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "list_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "list_prices": { + "file": "product/product.py", + "module": "product", + "relation": "product.list_price", + "required": null, + "settable": true, + "type": "One2Many" + }, + "lot_required": { + "file": "stock_lot/product.py", + "module": "stock_lot", + "relation": "product.template-stock.lot.type", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "name": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "producible": { + "file": "production/product.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "products": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": null, + "settable": true, + "type": "One2Many" + }, + "quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "shelf_life_state": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "shelf_life_time": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "type": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "volume": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "volume_digits": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "volume_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "weight": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "weight_digits": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "weight_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "width": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "width_digits": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "width_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.template-product.category": { + "fields": { + "category": { + "file": "product/product.py", + "module": "product", + "relation": "product.category", + "required": true, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.template-product.category.all": { + "fields": { + "category": { + "file": "product/product.py", + "module": "product", + "relation": "product.category", + "required": null, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.template-stock.lot.type": { + "fields": { + "template": { + "file": "stock_lot/product.py", + "module": "stock_lot", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "stock_lot/product.py", + "module": "stock_lot", + "relation": "stock.lot.type", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.uom": { + "fields": { + "category": { + "file": "product/uom.py", + "module": "product", + "relation": "product.uom.category", + "required": true, + "settable": true, + "type": "Many2One" + }, + "digits": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "factor": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "name": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "rate": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "rounding": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "symbol": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "product.uom.category": { + "fields": { + "name": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "uoms": { + "file": "product/uom.py", + "module": "product", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "production": { + "fields": { + "bom": { + "file": "production/production.py", + "module": "production", + "relation": "production.bom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "company": { + "file": "production/production.py", + "module": "production", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "cost": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "effective_date": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "effective_start_date": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "inputs": { + "file": "production/production.py", + "module": "production", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "location": { + "file": "production/production.py", + "module": "production", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "number": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "outputs": { + "file": "production/production.py", + "module": "production", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "planned_date": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "planned_start_date": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "product": { + "file": "production/production.py", + "module": "production", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "reference": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "unit_digits": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "uom": { + "file": "production/production.py", + "module": "production", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse": { + "file": "production/production.py", + "module": "production", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "production.assign": { + "fields": {}, + "persisted": false + }, + "production.assign.failed": { + "fields": { + "moves": { + "file": "production/production.py", + "module": "production", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "production.bom": { + "fields": { + "inputs": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.input", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "output_products": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.output", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "outputs": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.output", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "production.bom.input": { + "fields": { + "bom": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit_digits": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "uom": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "production.bom.output": { + "fields": {}, + "persisted": false + }, + "production.bom.tree": { + "fields": { + "childs": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.tree", + "required": null, + "settable": true, + "type": "One2Many" + }, + "product": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "unit_digits": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "uom": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "production.bom.tree.open": { + "fields": {}, + "persisted": false + }, + "production.bom.tree.open.start": { + "fields": { + "bom": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product-production.bom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "category": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom.category", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit_digits": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "uom": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "production.bom.tree.open.tree": { + "fields": { + "bom_tree": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.tree", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": false + }, + "production.configuration": { + "fields": { + "production_sequence": { + "file": "production/configuration.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + } + }, + "persisted": true + }, + "production.configuration.production_sequence": { + "fields": { + "production_sequence": { + "file": "production/configuration.py", + "module": "production", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "production.lead_time": { + "fields": { + "bom": { + "file": "production/product.py", + "module": "production", + "relation": "production.bom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "lead_time": { + "file": "production/product.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "TimeDelta" + }, + "product": { + "file": "production/product.py", + "module": "production", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "production.split": { + "fields": {}, + "persisted": false + }, + "production.split.start": { + "fields": { + "count": { + "file": "production_split/production.py", + "module": "production_split", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "quantity": { + "file": "production_split/production.py", + "module": "production_split", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit_digits": { + "file": "production_split/production.py", + "module": "production_split", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "uom": { + "file": "production_split/production.py", + "module": "production_split", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "production_split/production.py", + "module": "production_split", + "relation": "product.uom.category", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "res.group": { + "fields": { + "buttons": { + "file": "res/group.py", + "module": "res", + "relation": "ir.model.button-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "field_access": { + "file": "res/group.py", + "module": "res", + "relation": "ir.model.field.access", + "required": null, + "settable": true, + "type": "One2Many" + }, + "model_access": { + "file": "res/group.py", + "module": "res", + "relation": "ir.model.access", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "res/group.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "rule_groups": { + "file": "res/group.py", + "module": "res", + "relation": "ir.rule.group-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "users": { + "file": "res/group.py", + "module": "res", + "relation": "res.user-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": true + }, + "res.user": { + "fields": { + "actions": { + "file": "res/user.py", + "module": "res", + "relation": "res.user-ir.action", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "applications": { + "file": "res/user.py", + "module": "res", + "relation": "res.user.application", + "required": null, + "settable": true, + "type": "One2Many" + }, + "companies": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": false, + "type": "Function[One2Many]" + }, + "company": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "email": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "employee": { + "file": "company/company.py", + "module": "company", + "relation": "company.employee", + "required": null, + "settable": true, + "type": "Many2One" + }, + "employees": { + "file": "company/company.py", + "module": "company", + "relation": "res.user-company.employee", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "groups": { + "file": "res/user.py", + "module": "res", + "relation": "res.user-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "language": { + "file": "res/user.py", + "module": "res", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2One" + }, + "language_direction": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "login": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "main_company": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "menu": { + "file": "res/user.py", + "module": "res", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "password": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "password_hash": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "password_reset": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "password_reset_expire": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "pyson_menu": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "sessions": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "signature": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "status_bar": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "warnings": { + "file": "res/user.py", + "module": "res", + "relation": "res.user.warning", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "res.user-company.employee": { + "fields": { + "employee": { + "file": "company/company.py", + "module": "company", + "relation": "company.employee", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "company/company.py", + "module": "company", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user-ir.action": { + "fields": { + "action": { + "file": "res/user.py", + "module": "res", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user-res.group": { + "fields": { + "group": { + "file": "res/user.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user.application": { + "fields": { + "application": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "key": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "state": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user.config": { + "fields": {}, + "persisted": false + }, + "res.user.config.start": { + "fields": {}, + "persisted": false + }, + "res.user.email_reset_password": { + "fields": {}, + "persisted": false + }, + "res.user.login.attempt": { + "fields": { + "ip_address": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "ip_network": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "login": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "res.user.warning": { + "fields": { + "always": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "name": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.configuration": { + "fields": { + "inventory_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shelf_life_delay": { + "file": "stock_lot_sled/stock.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_in_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_in_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_internal_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_internal_transit": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_out_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_out_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + } + }, + "persisted": true + }, + "stock.configuration.location": { + "fields": {}, + "persisted": true + }, + "stock.configuration.sequence": { + "fields": { + "inventory_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_in_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_in_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_internal_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_out_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_out_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.inventory": { + "fields": { + "company": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "date": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "empty_quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "lines": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.inventory.line", + "required": null, + "settable": true, + "type": "One2Many" + }, + "location": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "lost_found": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "number": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "stock.inventory.count": { + "fields": {}, + "persisted": false + }, + "stock.inventory.count.quantity": { + "fields": { + "line": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.inventory.line", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity_added": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "quantity_resulting": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "unit_digits": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "uom": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "stock.inventory.count.search": { + "fields": { + "search": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "Search", + "required": true, + "settable": true, + "type": "Reference" + }, + "search_model": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + } + }, + "persisted": false + }, + "stock.inventory.line": { + "fields": { + "expected_quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "inventory": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.inventory", + "required": true, + "settable": true, + "type": "Many2One" + }, + "inventory_state": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "moves": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "product": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "unit_digits": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "uom": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.location": { + "fields": { + "address": { + "file": "stock/location.py", + "module": "stock", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "childs": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "One2Many" + }, + "code": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "cost_value": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "flat_childs": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "forecast_quantity": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "input_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "left": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "name": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "output_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "parent": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "picking_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_location": { + "file": "production/stock.py", + "module": "production", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "right": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "storage_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "warehouse": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.location.lead_time": { + "fields": { + "lead_time": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "TimeDelta" + }, + "warehouse_from": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "warehouse_to": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.location.lot.shelf_life": { + "fields": {}, + "persisted": true + }, + "stock.lot": { + "fields": { + "expiration_date": { + "file": "stock_lot_sled/stock.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "expiration_state": { + "file": "stock_lot_sled/stock.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + }, + "forecast_quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "number": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "product": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "shelf_life_expiration_date": { + "file": "stock_lot_sled/stock.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "shelf_life_expiration_state": { + "file": "stock_lot_sled/stock.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + } + }, + "persisted": true + }, + "stock.lot.type": { + "fields": { + "code": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "name": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "stock.lots_by_location.context": { + "fields": { + "forecast_date": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "stock_date_end": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Date]" + } + }, + "persisted": false + }, + "stock.move": { + "fields": { + "assignation_required": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "company": { + "file": "stock/move.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "cost_price": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "currency": { + "file": "stock/move.py", + "module": "stock", + "relation": "currency.currency", + "required": null, + "settable": true, + "type": "Many2One" + }, + "effective_date": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "from_location": { + "file": "stock/move.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "internal_quantity": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "internal_volume": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "internal_weight": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "origin": { + "file": "stock/move.py", + "module": "stock", + "relation": "Origin", + "required": null, + "settable": true, + "type": "Reference" + }, + "planned_date": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "product": { + "file": "stock/move.py", + "module": "stock", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product_uom_category": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "production_input": { + "file": "production/stock.py", + "module": "production", + "relation": "production", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_output": { + "file": "production/stock.py", + "module": "production", + "relation": "production", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "shipment": { + "file": "stock/move.py", + "module": "stock", + "relation": "Shipment", + "required": null, + "settable": true, + "type": "Reference" + }, + "state": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "to_location": { + "file": "stock/move.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "unit_digits": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "unit_price": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "unit_price_required": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "uom": { + "file": "stock/move.py", + "module": "stock", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.move.split": { + "fields": {}, + "persisted": false + }, + "stock.move.split.start": { + "fields": { + "count": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "quantity": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit_digits": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "uom": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "product.uom.category", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "stock.package": { + "fields": { + "additional_weight": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "total_volume": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "total_weight": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + } + }, + "persisted": false + }, + "stock.period": { + "fields": { + "caches": { + "file": "stock/period.py", + "module": "stock", + "relation": "stock.period.cache", + "required": null, + "settable": true, + "type": "One2Many" + }, + "company": { + "file": "stock/period.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "date": { + "file": "stock/period.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "lot_caches": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.period.cache.lot", + "required": null, + "settable": true, + "type": "One2Many" + }, + "state": { + "file": "stock/period.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "stock.period.cache": { + "fields": { + "internal_quantity": { + "file": "stock/period.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "location": { + "file": "stock/period.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "period": { + "file": "stock/period.py", + "module": "stock", + "relation": "stock.period", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock/period.py", + "module": "stock", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.period.cache.lot": { + "fields": { + "internal_quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "location": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "period": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.period", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.product.location": { + "fields": { + "location": { + "file": "stock_product_location/location.py", + "module": "stock_product_location", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock_product_location/location.py", + "module": "stock_product_location", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse": { + "file": "stock_product_location/location.py", + "module": "stock_product_location", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.product_quantities_warehouse": { + "fields": { + "quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + } + }, + "persisted": true + }, + "stock.product_quantities_warehouse.context": { + "fields": { + "warehouse": { + "file": "stock/product.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "stock.products_by_locations.context": { + "fields": { + "forecast_date": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "stock_date_end": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Date]" + } + }, + "persisted": false + }, + "stock.shipment.in": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "contact_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "effective_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "incoming_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "inventory_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "number": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "planned_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "reference": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "supplier": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "supplier_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_input": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse_storage": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.shipment.in.restocking_list": { + "fields": {}, + "persisted": false + }, + "stock.shipment.in.return": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "delivery_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "effective_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "from_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "number": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "planned_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "reference": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "supplier": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "to_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.shipment.in.return.assign": { + "fields": {}, + "persisted": false + }, + "stock.shipment.in.return.assign.failed": { + "fields": { + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "stock.shipment.internal": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "effective_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "effective_start_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "from_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "incoming_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "number": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "outgoing_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "planned_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "planned_start_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "reference": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "to_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "transit_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.shipment.internal.assign": { + "fields": {}, + "persisted": false + }, + "stock.shipment.internal.assign.failed": { + "fields": { + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "stock.shipment.internal.report": { + "fields": {}, + "persisted": false + }, + "stock.shipment.out": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "customer": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "customer_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "delivery_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": true, + "settable": true, + "type": "Many2One" + }, + "effective_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "inventory_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "number": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "outgoing_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "planned_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "reference": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_output": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse_storage": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.shipment.out.assign": { + "fields": {}, + "persisted": false + }, + "stock.shipment.out.assign.failed": { + "fields": { + "inventory_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "stock.shipment.out.delivery_note": { + "fields": {}, + "persisted": false + }, + "stock.shipment.out.picking_list": { + "fields": {}, + "persisted": false + }, + "stock.shipment.out.return": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "customer": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "customer_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "delivery_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": true, + "settable": true, + "type": "Many2One" + }, + "effective_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "incoming_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "inventory_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "number": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "planned_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "reference": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_input": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse_storage": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.shipment.out.return.restocking_list": { + "fields": {}, + "persisted": false + }, + "stock.shipment.split": { + "fields": {}, + "persisted": false + }, + "stock.shipment.split.start": { + "fields": { + "domain_moves": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "moves": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + } +} \ No newline at end of file diff --git a/reports/model_tree_5.0.md b/reports/model_tree_5.0.md new file mode 100644 index 0000000..89ebd4b --- /dev/null +++ b/reports/model_tree_5.0.md @@ -0,0 +1,1212 @@ +# Modellbaum (ir, res, company, country, currency, party, product, product_measurements, production, production_split, stock, stock_lot, stock_lot_sled, stock_product_location, stock_shipment_measurements, stock_split) + + +## `company.company` _(Felder aus: company)_ + +- **childs**: One2Many -> `company.company` +- **currency**: Many2One -> `currency.currency` required +- **employees**: One2Many -> `company.employee` +- **footer**: Text +- **header**: Text +- **parent**: Many2One -> `company.company` +- **party**: Many2One -> `party.party` required +- **timezone**: Selection + +## `company.employee` _(Felder aus: company)_ + +- **company**: Many2One -> `company.company` required +- **end_date**: Date +- **party**: Many2One -> `party.party` required +- **start_date**: Date + +## `country.country` _(Felder aus: country)_ + +- **code**: Char +- **code3**: Char +- **code_numeric**: Char +- **name**: Char required +- **subdivisions**: One2Many -> `country.subdivision` + +## `country.subdivision` _(Felder aus: country)_ + +- **code**: Char required +- **country**: Many2One -> `country.country` required +- **name**: Char required +- **parent**: Many2One -> `country.subdivision` +- **type**: Selection required + +## `country.zip` _(Felder aus: country)_ + +- **city**: Char +- **country**: Many2One -> `country.country` required +- **subdivision**: Many2One -> `country.subdivision` +- **zip**: Char + +## `currency.currency` _(Felder aus: currency)_ + +- **code**: Char required +- **digits**: Integer required +- **name**: Char required +- **numeric_code**: Char +- **rate**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **rates**: One2Many -> `currency.currency.rate` +- **rounding**: Numeric required +- **symbol**: Char required + +## `currency.currency.rate` _(Felder aus: currency)_ + +- **currency**: Many2One -> `currency.currency` +- **date**: Date required +- **rate**: Numeric + +## `ir.action` _(Felder aus: ir)_ + +- **groups**: Many2Many -> `ir.action-res.group` +- **icon**: Many2One -> `ir.ui.icon` +- **keywords**: One2Many -> `ir.action.keyword` +- **name**: Char required +- **type**: Char required +- **usage**: Char + +## `ir.action-res.group` _(Felder aus: res)_ + +- **action**: Many2One -> `ir.action` required (aus Modul `res`) +- **group**: Many2One -> `res.group` required (aus Modul `res`) + +## `ir.action.act_window` _(Felder aus: ir)_ + +- **act_window_domains**: One2Many -> `ir.action.act_window.domain` +- **act_window_views**: One2Many -> `ir.action.act_window.view` +- **action**: Many2One -> `ir.action` required +- **context**: Char +- **context_domain**: Char +- **context_model**: Char +- **domain**: Char +- **domains**: Function[Binary] NICHT setzbar (Function ohne setter) +- **limit**: Integer +- **order**: Char +- **pyson_context**: Function[Char] NICHT setzbar (Function ohne setter) +- **pyson_domain**: Function[Char] NICHT setzbar (Function ohne setter) +- **pyson_order**: Function[Char] NICHT setzbar (Function ohne setter) +- **pyson_search_value**: Function[Char] NICHT setzbar (Function ohne setter) +- **res_model**: Char +- **search_value**: Char +- **views**: Function[Binary] NICHT setzbar (Function ohne setter) + +## `ir.action.act_window.domain` _(Felder aus: ir)_ + +- **act_window**: Many2One -> `ir.action.act_window` required +- **count**: Boolean +- **domain**: Char +- **name**: Char +- **sequence**: Integer required + +## `ir.action.act_window.view` _(Felder aus: ir)_ + +- **act_window**: Many2One -> `ir.action.act_window` +- **sequence**: Integer required +- **view**: Many2One -> `ir.ui.view` required + +## `ir.action.keyword` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` +- **groups**: Function[One2Many] NICHT setzbar (Function ohne setter) +- **keyword**: Selection required +- **model**: Reference -> `Model` + +## `ir.action.report` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` required +- **direct_print**: Boolean +- **email**: Char +- **extension**: Selection +- **is_custom**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **model**: Char +- **module**: Char +- **pyson_email**: Function[Char] NICHT setzbar (Function ohne setter) +- **report**: Char +- **report_content**: Function[Binary] +- **report_content_custom**: Binary +- **report_content_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **report_name**: Char required +- **single**: Boolean +- **template_extension**: Selection required +- **translatable**: Boolean + +## `ir.action.url` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` required +- **url**: Char required + +## `ir.action.wizard` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` required +- **email**: Char +- **model**: Char +- **window**: Boolean +- **wiz_name**: Char required + +## `ir.attachment` _(Felder aus: ir)_ + +- **data**: Binary +- **data_size**: Function[Integer] NICHT setzbar (Function ohne setter) +- **description**: Text +- **file_id**: Char +- **link**: Char +- **name**: Char required +- **summary**: Function[Char] NICHT setzbar (Function ohne setter) +- **type**: Selection required + +## `ir.cache` _(Felder aus: ir)_ + +- **name**: Char required +- **timestamp**: Timestamp + +## `ir.configuration` _(Felder aus: ir)_ + +- **hostname**: Char +- **language**: Char + +## `ir.cron` _(Felder aus: company, ir)_ + +- **args**: Text +- **companies**: Many2Many -> `ir.cron-company.company` (aus Modul `company`) +- **function**: Char +- **interval_number**: Integer required +- **interval_type**: Selection +- **model**: Char +- **name**: Char required +- **next_call**: DateTime required +- **number_calls**: Integer required +- **repeat_missed**: Boolean +- **request_user**: Many2One -> `res.user` required +- **user**: Many2One -> `res.user` required + +## `ir.cron-company.company` _(Felder aus: company)_ + +- **company**: Many2One -> `company.company` required (aus Modul `company`) +- **cron**: Many2One -> `ir.cron` required (aus Modul `company`) + +## `ir.export` _(Felder aus: ir)_ + +- **export_fields**: One2Many -> `ir.export.line` +- **name**: Char +- **resource**: Char + +## `ir.export.line` _(Felder aus: ir)_ + +- **export**: Many2One -> `ir.export` required +- **name**: Char + +## `ir.lang` _(Felder aus: ir)_ + +- **code**: Char required +- **date**: Char required +- **decimal_point**: Char required +- **direction**: Selection required +- **grouping**: Char required +- **mon_decimal_point**: Char required +- **mon_grouping**: Char required +- **mon_thousands_sep**: Char +- **n_cs_precedes**: Boolean +- **n_sep_by_space**: Boolean +- **n_sign_posn**: Integer required +- **name**: Char required +- **negative_sign**: Char +- **p_cs_precedes**: Boolean +- **p_sep_by_space**: Boolean +- **p_sign_posn**: Integer required +- **parent**: Char +- **positive_sign**: Char +- **thousands_sep**: Char +- **translatable**: Boolean + +## `ir.model` _(Felder aus: ir)_ + +- **fields**: One2Many -> `ir.model.field` required +- **global_search_p**: Boolean +- **info**: Text +- **model**: Char required +- **module**: Char +- **name**: Char + +## `ir.model.access` _(Felder aus: ir)_ + +- **description**: Text +- **group**: Many2One -> `res.group` +- **model**: Many2One -> `ir.model` required +- **perm_create**: Boolean +- **perm_delete**: Boolean +- **perm_read**: Boolean +- **perm_write**: Boolean + +## `ir.model.button` _(Felder aus: ir)_ + +- **clicks**: One2Many -> `ir.model.button.click` +- **confirm**: Text +- **groups**: Many2Many -> `ir.model.button-res.group` +- **help**: Text +- **model**: Many2One -> `ir.model` required +- **name**: Char required +- **reset**: Many2Many -> `ir.model.button-button.reset` +- **reset_by**: Many2Many -> `ir.model.button-button.reset` +- **rules**: One2Many -> `ir.model.button.rule` +- **string**: Char + +## `ir.model.button-button.reset` _(Felder aus: ir)_ + +- **button**: Many2One -> `ir.model.button` required +- **button_ruled**: Many2One -> `ir.model.button` required + +## `ir.model.button-res.group` _(Felder aus: res)_ + +- **button**: Many2One -> `ir.model.button` required (aus Modul `res`) +- **group**: Many2One -> `res.group` required (aus Modul `res`) + +## `ir.model.button.click` _(Felder aus: ir, res)_ + +- **button**: Many2One -> `ir.model.button` required +- **record_id**: Integer required +- **user**: Many2One -> `res.user` (aus Modul `res`) + +## `ir.model.button.rule` _(Felder aus: ir, res)_ + +- **button**: Many2One -> `ir.model.button` required +- **condition**: Char +- **description**: Char +- **group**: Many2One -> `res.group` (aus Modul `res`) +- **number_user**: Integer required + +## `ir.model.data` _(Felder aus: ir)_ + +- **db_id**: Integer required +- **fs_id**: Char required +- **fs_values**: Text +- **model**: Char required +- **module**: Char required +- **noupdate**: Boolean +- **out_of_sync**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **values**: Text + +## `ir.model.field` _(Felder aus: ir)_ + +- **field_description**: Char +- **groups**: Many2Many -> `ir.model.field-res.group` +- **help**: Text +- **model**: Many2One -> `ir.model` required +- **module**: Char +- **name**: Char required +- **relation**: Char +- **ttype**: Char + +## `ir.model.field-res.group` _(Felder aus: res)_ + +- **field**: Many2One -> `ir.model.field` required (aus Modul `res`) +- **group**: Many2One -> `res.group` required (aus Modul `res`) + +## `ir.model.field.access` _(Felder aus: ir)_ + +- **description**: Text +- **field**: Many2One -> `ir.model.field` required +- **group**: Many2One -> `res.group` +- **perm_create**: Boolean +- **perm_delete**: Boolean +- **perm_read**: Boolean +- **perm_write**: Boolean + +## `ir.model.print_model_graph.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **filter**: Text +- **level**: Integer required + +## `ir.module` _(Felder aus: ir)_ + +- **childs**: Function[One2Many] NICHT setzbar (Function ohne setter) +- **dependencies**: One2Many -> `ir.module.dependency` +- **name**: Char required +- **parents**: Function[One2Many] NICHT setzbar (Function ohne setter) +- **state**: Selection +- **version**: Function[Char] NICHT setzbar (Function ohne setter) + +## `ir.module.activate_upgrade.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **module_info**: Text + +## `ir.module.config_wizard.item` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` required +- **sequence**: Integer required +- **state**: Selection required + +## `ir.module.config_wizard.other` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **percentage**: Float + +## `ir.module.dependency` _(Felder aus: ir)_ + +- **module**: Many2One -> `ir.module` required +- **name**: Char +- **state**: Function[Selection] NICHT setzbar (Function ohne setter) + +## `ir.note` _(Felder aus: ir)_ + +- **message**: Text +- **message_wrapped**: Function[Text] NICHT setzbar (Function ohne setter) +- **unread**: Function[Boolean] + +## `ir.note.read` _(Felder aus: ir)_ + +- **note**: Many2One -> `ir.note` required +- **user**: Many2One -> `res.user` required + +## `ir.queue` _(Felder aus: ir)_ + +- **data**: Dict +- **dequeued_at**: Timestamp +- **enqueued_at**: Timestamp required +- **expected_at**: Timestamp +- **finished_at**: Timestamp +- **name**: Char required +- **scheduled_at**: Timestamp + +## `ir.rule` _(Felder aus: ir)_ + +- **domain**: Char required +- **rule_group**: Many2One -> `ir.rule.group` required + +## `ir.rule.group` _(Felder aus: ir)_ + +- **default_p**: Boolean +- **global_p**: Boolean +- **groups**: Many2Many -> `ir.rule.group-res.group` +- **model**: Many2One -> `ir.model` required +- **name**: Char +- **perm_create**: Boolean +- **perm_delete**: Boolean +- **perm_read**: Boolean +- **perm_write**: Boolean +- **rules**: One2Many -> `ir.rule` + +## `ir.rule.group-res.group` _(Felder aus: res)_ + +- **group**: Many2One -> `res.group` required (aus Modul `res`) +- **rule_group**: Many2One -> `ir.rule.group` required (aus Modul `res`) + +## `ir.sequence` _(Felder aus: company, ir, res)_ + +- **code**: Selection required +- **company**: Many2One -> `company.company` (aus Modul `company`) +- **groups**: Function[Many2Many] NICHT setzbar (Function ohne setter) (aus Modul `res`) +- **last_timestamp**: Integer +- **name**: Char required +- **number_increment**: Integer +- **number_next**: Function NICHT setzbar (Function ohne setter) +- **number_next_internal**: Integer +- **padding**: Integer +- **prefix**: Char +- **suffix**: Char +- **timestamp_offset**: Float required +- **timestamp_rounding**: Float required +- **type**: Selection + +## `ir.sequence.type` _(Felder aus: ir, res)_ + +- **code**: Char required +- **groups**: Many2Many -> `ir.sequence.type-res.group` (aus Modul `res`) +- **name**: Char required + +## `ir.sequence.type-res.group` _(Felder aus: res)_ + +- **group**: Many2One -> `res.group` required (aus Modul `res`) +- **sequence_type**: Many2One -> `ir.sequence.type` required (aus Modul `res`) + +## `ir.session` _(Felder aus: ir)_ + +- **key**: Char required + +## `ir.session.wizard` _(Felder aus: ir)_ + +- **data**: Text + +## `ir.translation` _(Felder aus: ir)_ + +- **fuzzy**: Boolean +- **lang**: Selection +- **model**: Function[Char] NICHT setzbar (Function ohne setter) +- **module**: Char +- **name**: Char required +- **overriding_module**: Char +- **res_id**: Integer required +- **src**: Text +- **src_md5**: Char required +- **type**: Selection required +- **value**: Text + +## `ir.translation.export.result` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **file**: Binary + +## `ir.translation.export.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **language**: Many2One -> `ir.lang` required +- **module**: Many2One -> `ir.module` required + +## `ir.translation.update.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **language**: Many2One -> `ir.lang` required + +## `ir.trigger` _(Felder aus: ir)_ + +- **action_function**: Char required +- **action_model**: Many2One -> `ir.model` required +- **condition**: Char required +- **limit_number**: Integer required +- **minimum_time_delay**: TimeDelta +- **model**: Many2One -> `ir.model` required +- **name**: Char required +- **on_create**: Boolean +- **on_delete**: Boolean +- **on_time**: Boolean +- **on_write**: Boolean + +## `ir.trigger.log` _(Felder aus: ir)_ + +- **record_id**: Integer required +- **trigger**: Many2One -> `ir.trigger` required + +## `ir.ui.icon` _(Felder aus: ir)_ + +- **icon**: Function[Char] NICHT setzbar (Function ohne setter) +- **module**: Char required +- **name**: Char required +- **path**: Char required +- **sequence**: Integer required + +## `ir.ui.menu` _(Felder aus: ir)_ + +- **action**: Function[Reference] +- **action_keywords**: One2Many -> `ir.action.keyword` +- **childs**: One2Many -> `ir.ui.menu` +- **complete_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **favorite**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **groups**: Many2Many -> `ir.ui.menu-res.group` +- **icon**: Selection +- **name**: Char required +- **parent**: Many2One -> `ir.ui.menu` + +## `ir.ui.menu-res.group` _(Felder aus: res)_ + +- **group**: Many2One -> `res.group` required (aus Modul `res`) +- **menu**: Many2One -> `ir.ui.menu` required (aus Modul `res`) + +## `ir.ui.menu.favorite` _(Felder aus: ir)_ + +- **menu**: Many2One -> `ir.ui.menu` required +- **user**: Many2One -> `res.user` required + +## `ir.ui.view` _(Felder aus: ir)_ + +- **arch**: Function[Text] +- **data**: Text +- **domain**: Char +- **field_childs**: Char +- **inherit**: Many2One -> `ir.ui.view` +- **model**: Char +- **module**: Char +- **name**: Char +- **priority**: Integer required +- **type**: Selection + +## `ir.ui.view_search` _(Felder aus: ir)_ + +- **domain**: Char +- **model**: Char required +- **name**: Char required +- **user**: Many2One -> `res.user` required + +## `ir.ui.view_tree_state` _(Felder aus: ir)_ + +- **child_name**: Char +- **domain**: Char required +- **model**: Char required +- **nodes**: Text +- **selected_nodes**: Text +- **user**: Many2One -> `res.user` required + +## `ir.ui.view_tree_width` _(Felder aus: ir)_ + +- **field**: Char required +- **model**: Char required +- **user**: Many2One -> `res.user` required +- **width**: Integer required + +## `party.address` _(Felder aus: party, stock)_ + +- **city**: Char +- **country**: Many2One -> `country.country` +- **delivery**: Boolean (aus Modul `stock`) +- **full_address**: Function[Text] NICHT setzbar (Function ohne setter) +- **name**: Char +- **party**: Many2One -> `party.party` required +- **party_name**: Char +- **street**: Text +- **subdivision**: Many2One -> `country.subdivision` +- **zip**: Char + +## `party.address.format` _(Felder aus: party)_ + +- **country**: Many2One -> `country.country` +- **format_**: Text required +- **language**: Many2One -> `ir.lang` + +## `party.category` _(Felder aus: party)_ + +- **childs**: One2Many -> `party.category` +- **name**: Char required +- **parent**: Many2One -> `party.category` + +## `party.check_vies.result` _(Wizard/Transient - nicht persistent)_ _(Felder aus: party)_ + +- **parties_failed**: Many2Many -> `party.party` +- **parties_succeed**: Many2Many -> `party.party` + +## `party.configuration` _(Felder aus: party)_ + +- **party_lang**: MultiValue +- **party_sequence**: MultiValue + +## `party.contact_mechanism` _(Felder aus: party)_ + +- **comment**: Text +- **email**: Function[Char] +- **name**: Char +- **other_value**: Function[Char] +- **party**: Many2One -> `party.party` required +- **sip**: Function[Char] +- **skype**: Function[Char] +- **type**: Selection required +- **url**: Function[Char] NICHT setzbar (Function ohne setter) +- **value**: Char +- **value_compact**: Char +- **website**: Function[Char] + +## `party.erase.ask` _(Wizard/Transient - nicht persistent)_ _(Felder aus: party)_ + +- **party**: Many2One -> `party.party` required + +## `party.identifier` _(Felder aus: party)_ + +- **code**: Char required +- **party**: Many2One -> `party.party` required +- **type**: Selection + +## `party.party` _(Felder aus: party, stock)_ + +- **addresses**: One2Many -> `party.address` +- **categories**: Many2Many -> `party.party-party.category` +- **code**: Char required +- **code_readonly**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **contact_mechanisms**: One2Many -> `party.contact_mechanism` +- **customer_location**: MultiValue (aus Modul `stock`) +- **email**: Function[Char] NICHT setzbar (Function ohne setter) +- **fax**: Function[Char] NICHT setzbar (Function ohne setter) +- **full_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **identifiers**: One2Many -> `party.identifier` +- **lang**: MultiValue +- **langs**: One2Many -> `party.party.lang` +- **locations**: One2Many -> `party.party.location` (aus Modul `stock`) +- **mobile**: Function[Char] NICHT setzbar (Function ohne setter) +- **name**: Char +- **phone**: Function[Char] NICHT setzbar (Function ohne setter) +- **replaced_by**: Many2One -> `party.party` +- **supplier_location**: MultiValue (aus Modul `stock`) +- **tax_identifier**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **website**: Function[Char] NICHT setzbar (Function ohne setter) + +## `party.party-party.category` _(Felder aus: party)_ + +- **category**: Many2One -> `party.category` required +- **party**: Many2One -> `party.party` required + +## `party.party.lang` _(Felder aus: party)_ + +- **lang**: Many2One -> `ir.lang` +- **party**: Many2One -> `party.party` + +## `party.party.location` _(Felder aus: stock)_ + +- **party**: Many2One -> `party.party` (aus Modul `stock`) + +## `party.replace.ask` _(Wizard/Transient - nicht persistent)_ _(Felder aus: party)_ + +- **destination**: Many2One -> `party.party` required +- **source**: Many2One -> `party.party` required + +## `product.by_location.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **forecast_date**: Date (aus Modul `stock`) +- **stock_date_end**: Function[Date] NICHT setzbar (Function ohne setter) (aus Modul `stock`) + +## `product.category` _(Felder aus: product)_ + +- **childs**: One2Many -> `product.category` +- **name**: Char required +- **parent**: Many2One -> `product.category` + +## `product.configuration` _(Felder aus: product)_ + +- **default_cost_price_method**: MultiValue + +## `product.cost_price` _(Felder aus: product)_ + +- **cost_price**: Numeric +- **product**: Many2One -> `product.product` + +## `product.cost_price_method` _(Felder aus: product)_ + +- **cost_price_method**: Selection +- **template**: Many2One -> `product.template` + +## `product.list_price` _(Felder aus: product)_ + +- **list_price**: Numeric +- **template**: Many2One -> `product.template` + +## `product.product` _(Felder aus: product, production, stock, stock_product_location)_ + +- **boms**: One2Many -> `product.product-production.bom` (aus Modul `production`) +- **code**: Char +- **cost_price**: MultiValue +- **cost_price_uom**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **cost_prices**: One2Many -> `product.cost_price` +- **cost_value**: Function[Numeric] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **description**: Text +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **lead_times**: One2Many -> `production.lead_time` (aus Modul `production`) +- **list_price_uom**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **locations**: One2Many -> `stock.product.location` (aus Modul `stock_product_location`) +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **template**: Many2One -> `product.template` required + +## `product.product-production.bom` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` required (aus Modul `production`) +- **product**: Many2One -> `product.product` required (aus Modul `production`) + +## `product.template` _(Felder aus: product, product_measurements, production, stock, stock_lot, stock_lot_sled)_ + +- **categories**: Many2Many -> `product.template-product.category` +- **categories_all**: Many2Many -> `product.template-product.category.all` +- **consumable**: Boolean +- **cost_price**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **cost_price_method**: MultiValue +- **cost_price_methods**: One2Many -> `product.cost_price_method` +- **cost_value**: Function[Numeric] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **default_uom**: Many2One -> `product.uom` required +- **default_uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **expiration_state**: Selection (aus Modul `stock_lot_sled`) +- **expiration_time**: Integer (aus Modul `stock_lot_sled`) +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **height**: Float (aus Modul `product_measurements`) +- **height_digits**: Function[Integer] NICHT setzbar (Function ohne setter) (aus Modul `product_measurements`) +- **height_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **length**: Float (aus Modul `product_measurements`) +- **length_digits**: Function[Integer] NICHT setzbar (Function ohne setter) (aus Modul `product_measurements`) +- **length_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **list_price**: MultiValue +- **list_prices**: One2Many -> `product.list_price` +- **lot_required**: Many2Many -> `product.template-stock.lot.type` (aus Modul `stock_lot`) +- **name**: Char required +- **producible**: Boolean (aus Modul `production`) +- **products**: One2Many -> `product.product` +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **shelf_life_state**: Selection (aus Modul `stock_lot_sled`) +- **shelf_life_time**: Integer (aus Modul `stock_lot_sled`) +- **type**: Selection required +- **volume**: Float (aus Modul `product_measurements`) +- **volume_digits**: Function[Integer] NICHT setzbar (Function ohne setter) (aus Modul `product_measurements`) +- **volume_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **weight**: Float (aus Modul `product_measurements`) +- **weight_digits**: Function[Integer] NICHT setzbar (Function ohne setter) (aus Modul `product_measurements`) +- **weight_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **width**: Float (aus Modul `product_measurements`) +- **width_digits**: Function[Integer] NICHT setzbar (Function ohne setter) (aus Modul `product_measurements`) +- **width_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) + +## `product.template-product.category` _(Felder aus: product)_ + +- **category**: Many2One -> `product.category` required +- **template**: Many2One -> `product.template` required + +## `product.template-product.category.all` _(Felder aus: product)_ + +- **category**: Many2One -> `product.category` +- **template**: Many2One -> `product.template` + +## `product.template-stock.lot.type` _(Felder aus: stock_lot)_ + +- **template**: Many2One -> `product.template` required (aus Modul `stock_lot`) +- **type**: Many2One -> `stock.lot.type` required (aus Modul `stock_lot`) + +## `product.uom` _(Felder aus: product)_ + +- **category**: Many2One -> `product.uom.category` required +- **digits**: Integer required +- **factor**: Float required +- **name**: Char required +- **rate**: Float required +- **rounding**: Float required +- **symbol**: Char required + +## `product.uom.category` _(Felder aus: product)_ + +- **name**: Char required +- **uoms**: One2Many -> `product.uom` + +## `production` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` +- **company**: Many2One -> `company.company` required +- **cost**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **effective_date**: Date +- **effective_start_date**: Date +- **inputs**: One2Many -> `stock.move` +- **location**: Many2One -> `stock.location` required +- **number**: Char +- **outputs**: One2Many -> `stock.move` +- **planned_date**: Date +- **planned_start_date**: Date +- **product**: Many2One -> `product.product` +- **quantity**: Float +- **reference**: Char +- **state**: Selection +- **unit_digits**: Function[Integer] NICHT setzbar (Function ohne setter) +- **uom**: Many2One -> `product.uom` +- **uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse**: Many2One -> `stock.location` required + +## `production.assign.failed` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production)_ + +- **moves**: Many2Many -> `stock.move` + +## `production.bom` _(Felder aus: production)_ + +- **inputs**: One2Many -> `production.bom.input` +- **name**: Char required +- **output_products**: Many2Many -> `production.bom.output` +- **outputs**: One2Many -> `production.bom.output` + +## `production.bom.input` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` required +- **product**: Many2One -> `product.product` required +- **quantity**: Float required +- **unit_digits**: Function[Integer] NICHT setzbar (Function ohne setter) +- **uom**: Many2One -> `product.uom` required +- **uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `production.bom.tree` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production)_ + +- **childs**: One2Many -> `production.bom.tree` +- **product**: Many2One -> `product.product` +- **quantity**: Float +- **unit_digits**: Integer +- **uom**: Many2One -> `product.uom` + +## `production.bom.tree.open.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production)_ + +- **bom**: Many2One -> `product.product-production.bom` required +- **category**: Many2One -> `product.uom.category` +- **product**: Many2One -> `product.product` +- **quantity**: Float required +- **unit_digits**: Integer +- **uom**: Many2One -> `product.uom` required + +## `production.bom.tree.open.tree` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production)_ + +- **bom_tree**: One2Many -> `production.bom.tree` + +## `production.configuration` _(Felder aus: production)_ + +- **production_sequence**: MultiValue + +## `production.configuration.production_sequence` _(Felder aus: production)_ + +- **production_sequence**: Many2One -> `ir.sequence` required + +## `production.lead_time` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` +- **lead_time**: TimeDelta +- **product**: Many2One -> `product.product` required + +## `production.split.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production_split)_ + +- **count**: Integer (aus Modul `production_split`) +- **quantity**: Float required (aus Modul `production_split`) +- **unit_digits**: Integer (aus Modul `production_split`) +- **uom**: Many2One -> `product.uom` required (aus Modul `production_split`) +- **uom_category**: Many2One -> `product.uom.category` (aus Modul `production_split`) + +## `res.group` _(Felder aus: res)_ + +- **buttons**: Many2Many -> `ir.model.button-res.group` +- **field_access**: One2Many -> `ir.model.field.access` +- **model_access**: One2Many -> `ir.model.access` +- **name**: Char required +- **rule_groups**: Many2Many -> `ir.rule.group-res.group` +- **users**: Many2Many -> `res.user-res.group` + +## `res.user` _(Felder aus: company, res)_ + +- **actions**: Many2Many -> `res.user-ir.action` +- **applications**: One2Many -> `res.user.application` +- **companies**: Function[One2Many] NICHT setzbar (Function ohne setter) (aus Modul `company`) +- **company**: Many2One -> `company.company` (aus Modul `company`) +- **email**: Char +- **employee**: Many2One -> `company.employee` (aus Modul `company`) +- **employees**: Many2Many -> `res.user-company.employee` (aus Modul `company`) +- **groups**: Many2Many -> `res.user-res.group` +- **language**: Many2One -> `ir.lang` +- **language_direction**: Function[Char] NICHT setzbar (Function ohne setter) +- **login**: Char required +- **main_company**: Many2One -> `company.company` (aus Modul `company`) +- **menu**: Many2One -> `ir.action` required +- **name**: Char +- **password**: Function[Char] +- **password_hash**: Char +- **password_reset**: Char +- **password_reset_expire**: Timestamp +- **pyson_menu**: Function[Char] NICHT setzbar (Function ohne setter) +- **sessions**: Function[Integer] NICHT setzbar (Function ohne setter) +- **signature**: Text +- **status_bar**: Function[Char] NICHT setzbar (Function ohne setter) +- **warnings**: One2Many -> `res.user.warning` + +## `res.user-company.employee` _(Felder aus: company)_ + +- **employee**: Many2One -> `company.employee` required (aus Modul `company`) +- **user**: Many2One -> `res.user` required (aus Modul `company`) + +## `res.user-ir.action` _(Felder aus: res)_ + +- **action**: Many2One -> `ir.action` required +- **user**: Many2One -> `res.user` required + +## `res.user-res.group` _(Felder aus: res)_ + +- **group**: Many2One -> `res.group` required +- **user**: Many2One -> `res.user` required + +## `res.user.application` _(Felder aus: res)_ + +- **application**: Selection +- **key**: Char required +- **state**: Selection +- **user**: Many2One -> `res.user` + +## `res.user.login.attempt` _(Felder aus: res)_ + +- **ip_address**: Char +- **ip_network**: Char +- **login**: Char + +## `res.user.warning` _(Felder aus: res)_ + +- **always**: Boolean +- **name**: Char required +- **user**: Many2One -> `res.user` required + +## `stock.configuration` _(Felder aus: stock, stock_lot_sled)_ + +- **inventory_sequence**: MultiValue +- **shelf_life_delay**: MultiValue (aus Modul `stock_lot_sled`) +- **shipment_in_return_sequence**: MultiValue +- **shipment_in_sequence**: MultiValue +- **shipment_internal_sequence**: MultiValue +- **shipment_internal_transit**: MultiValue +- **shipment_out_return_sequence**: MultiValue +- **shipment_out_sequence**: MultiValue + +## `stock.configuration.sequence` _(Felder aus: stock)_ + +- **inventory_sequence**: Many2One -> `ir.sequence` required +- **shipment_in_return_sequence**: Many2One -> `ir.sequence` required +- **shipment_in_sequence**: Many2One -> `ir.sequence` required +- **shipment_internal_sequence**: Many2One -> `ir.sequence` required +- **shipment_out_return_sequence**: Many2One -> `ir.sequence` required +- **shipment_out_sequence**: Many2One -> `ir.sequence` required + +## `stock.inventory` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **date**: Date required +- **empty_quantity**: Selection +- **lines**: One2Many -> `stock.inventory.line` +- **location**: Many2One -> `stock.location` required +- **lost_found**: Many2One -> `stock.location` required +- **number**: Char +- **state**: Selection + +## `stock.inventory.count.quantity` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **line**: Many2One -> `stock.inventory.line` required +- **product**: Many2One -> `product.product` +- **quantity_added**: Float required +- **quantity_resulting**: Float +- **unit_digits**: Integer +- **uom**: Many2One -> `product.uom` + +## `stock.inventory.count.search` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **search**: Reference -> `Search` required +- **search_model**: Function[Selection] NICHT setzbar (Function ohne setter) + +## `stock.inventory.line` _(Felder aus: stock, stock_lot)_ + +- **expected_quantity**: Float required +- **inventory**: Many2One -> `stock.inventory` required +- **inventory_state**: Function[Selection] NICHT setzbar (Function ohne setter) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **moves**: One2Many -> `stock.move` +- **product**: Many2One -> `product.product` required +- **quantity**: Float +- **unit_digits**: Function[Integer] NICHT setzbar (Function ohne setter) +- **uom**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.location` _(Felder aus: production, stock)_ + +- **address**: Many2One -> `party.address` +- **childs**: One2Many -> `stock.location` +- **code**: Char +- **cost_value**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **flat_childs**: Boolean +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) +- **input_location**: Many2One -> `stock.location` +- **left**: Integer required +- **name**: Char required +- **output_location**: Many2One -> `stock.location` +- **parent**: Many2One -> `stock.location` +- **picking_location**: Many2One -> `stock.location` +- **production_location**: Many2One -> `stock.location` (aus Modul `production`) +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) +- **right**: Integer required +- **storage_location**: Many2One -> `stock.location` +- **type**: Selection +- **warehouse**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.location.lead_time` _(Felder aus: stock)_ + +- **lead_time**: TimeDelta +- **warehouse_from**: Many2One -> `stock.location` +- **warehouse_to**: Many2One -> `stock.location` + +## `stock.lot` _(Felder aus: stock_lot, stock_lot_sled)_ + +- **expiration_date**: Date (aus Modul `stock_lot_sled`) +- **expiration_state**: Function[Selection] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot_sled`) +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **number**: Char required (aus Modul `stock_lot`) +- **product**: Many2One -> `product.product` required (aus Modul `stock_lot`) +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **shelf_life_expiration_date**: Date (aus Modul `stock_lot_sled`) +- **shelf_life_expiration_state**: Function[Selection] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot_sled`) + +## `stock.lot.type` _(Felder aus: stock_lot)_ + +- **code**: Char required (aus Modul `stock_lot`) +- **name**: Char required (aus Modul `stock_lot`) + +## `stock.lots_by_location.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_lot)_ + +- **forecast_date**: Date (aus Modul `stock_lot`) +- **stock_date_end**: Function[Date] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) + +## `stock.move` _(Felder aus: production, stock, stock_lot, stock_shipment_measurements)_ + +- **assignation_required**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **company**: Many2One -> `company.company` required +- **cost_price**: Numeric +- **currency**: Many2One -> `currency.currency` +- **effective_date**: Date +- **from_location**: Many2One -> `stock.location` required +- **internal_quantity**: Float required +- **internal_volume**: Float (aus Modul `stock_shipment_measurements`) +- **internal_weight**: Float (aus Modul `stock_shipment_measurements`) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **origin**: Reference -> `Origin` +- **planned_date**: Date +- **product**: Many2One -> `product.product` required +- **product_uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **production_input**: Many2One -> `production` (aus Modul `production`) +- **production_output**: Many2One -> `production` (aus Modul `production`) +- **quantity**: Float required +- **shipment**: Reference -> `Shipment` +- **state**: Selection +- **to_location**: Many2One -> `stock.location` required +- **unit_digits**: Function[Integer] NICHT setzbar (Function ohne setter) +- **unit_price**: Numeric +- **unit_price_required**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **uom**: Many2One -> `product.uom` required + +## `stock.move.split.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_split)_ + +- **count**: Integer (aus Modul `stock_split`) +- **quantity**: Float required (aus Modul `stock_split`) +- **unit_digits**: Integer (aus Modul `stock_split`) +- **uom**: Many2One -> `product.uom` required (aus Modul `stock_split`) +- **uom_category**: Many2One -> `product.uom.category` (aus Modul `stock_split`) + +## `stock.package` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_shipment_measurements)_ + +- **additional_weight**: Float (aus Modul `stock_shipment_measurements`) +- **total_volume**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_shipment_measurements`) +- **total_weight**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_shipment_measurements`) + +## `stock.period` _(Felder aus: stock, stock_lot)_ + +- **caches**: One2Many -> `stock.period.cache` +- **company**: Many2One -> `company.company` required +- **date**: Date required +- **lot_caches**: One2Many -> `stock.period.cache.lot` (aus Modul `stock_lot`) +- **state**: Selection + +## `stock.period.cache` _(Felder aus: stock)_ + +- **internal_quantity**: Float +- **location**: Many2One -> `stock.location` required +- **period**: Many2One -> `stock.period` required +- **product**: Many2One -> `product.product` required + +## `stock.period.cache.lot` _(Felder aus: stock_lot)_ + +- **internal_quantity**: Float (aus Modul `stock_lot`) +- **location**: Many2One -> `stock.location` required (aus Modul `stock_lot`) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **period**: Many2One -> `stock.period` required (aus Modul `stock_lot`) +- **product**: Many2One -> `product.product` required (aus Modul `stock_lot`) + +## `stock.product.location` _(Felder aus: stock_product_location)_ + +- **location**: Many2One -> `stock.location` required (aus Modul `stock_product_location`) +- **product**: Many2One -> `product.product` required (aus Modul `stock_product_location`) +- **warehouse**: Many2One -> `stock.location` required (aus Modul `stock_product_location`) + +## `stock.product_quantities_warehouse` _(Felder aus: stock)_ + +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) + +## `stock.product_quantities_warehouse.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **warehouse**: Many2One -> `stock.location` required + +## `stock.products_by_locations.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **forecast_date**: Date +- **stock_date_end**: Function[Date] NICHT setzbar (Function ohne setter) + +## `stock.shipment.in` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **contact_address**: Many2One -> `party.address` +- **effective_date**: Date +- **incoming_moves**: Function[One2Many] +- **inventory_moves**: Function[One2Many] +- **moves**: One2Many -> `stock.move` +- **number**: Char +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **planned_date**: Date +- **reference**: Char +- **state**: Selection +- **supplier**: Many2One -> `party.party` required +- **supplier_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse**: Many2One -> `stock.location` required +- **warehouse_input**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse_storage**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.shipment.in.return` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **delivery_address**: Many2One -> `party.address` +- **effective_date**: Date +- **from_location**: Many2One -> `stock.location` required +- **moves**: One2Many -> `stock.move` +- **number**: Char +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **planned_date**: Date +- **reference**: Char +- **state**: Selection +- **supplier**: Many2One -> `party.party` required +- **to_location**: Many2One -> `stock.location` required + +## `stock.shipment.in.return.assign.failed` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **moves**: Many2Many -> `stock.move` + +## `stock.shipment.internal` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **effective_date**: Date +- **effective_start_date**: Date +- **from_location**: Many2One -> `stock.location` required +- **incoming_moves**: Function[One2Many] +- **moves**: One2Many -> `stock.move` +- **number**: Char +- **outgoing_moves**: Function[One2Many] +- **planned_date**: Date +- **planned_start_date**: Date +- **reference**: Char +- **state**: Selection +- **to_location**: Many2One -> `stock.location` required +- **transit_location**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.shipment.internal.assign.failed` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **moves**: Many2Many -> `stock.move` + +## `stock.shipment.out` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **customer**: Many2One -> `party.party` required +- **customer_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **delivery_address**: Many2One -> `party.address` required +- **effective_date**: Date +- **inventory_moves**: Function[One2Many] +- **moves**: One2Many -> `stock.move` +- **number**: Char +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **outgoing_moves**: Function[One2Many] +- **planned_date**: Date +- **reference**: Char +- **state**: Selection +- **warehouse**: Many2One -> `stock.location` required +- **warehouse_output**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse_storage**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.shipment.out.assign.failed` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **inventory_moves**: Many2Many -> `stock.move` + +## `stock.shipment.out.return` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **customer**: Many2One -> `party.party` required +- **customer_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **delivery_address**: Many2One -> `party.address` required +- **effective_date**: Date +- **incoming_moves**: Function[One2Many] +- **inventory_moves**: Function[One2Many] +- **moves**: One2Many -> `stock.move` +- **number**: Char +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **planned_date**: Date +- **reference**: Char +- **state**: Selection +- **warehouse**: Many2One -> `stock.location` required +- **warehouse_input**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse_storage**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.shipment.split.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_split)_ + +- **domain_moves**: Many2Many -> `stock.move` (aus Modul `stock_split`) +- **moves**: Many2Many -> `stock.move` (aus Modul `stock_split`) diff --git a/reports/model_tree_8.0.json b/reports/model_tree_8.0.json new file mode 100644 index 0000000..29d3328 --- /dev/null +++ b/reports/model_tree_8.0.json @@ -0,0 +1,9850 @@ +{ + "company.company": { + "fields": { + "currency": { + "file": "company/company.py", + "module": "company", + "relation": "currency.currency", + "required": true, + "settable": true, + "type": "Many2One" + }, + "employees": { + "file": "company/company.py", + "module": "company", + "relation": "company.employee", + "required": null, + "settable": true, + "type": "One2Many" + }, + "footer": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "header": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "logo": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Binary" + }, + "logo_cache": { + "file": "company/company.py", + "module": "company", + "relation": "company.company.logo.cache", + "required": null, + "settable": true, + "type": "One2Many" + }, + "party": { + "file": "company/company.py", + "module": "company", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "tax_identifiers": { + "file": "company/company.py", + "module": "company", + "relation": "company.company.tax_identifier", + "required": null, + "settable": true, + "type": "One2Many" + }, + "timezone": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "company.company.config": { + "fields": {}, + "persisted": false + }, + "company.company.config.start": { + "fields": {}, + "persisted": false + }, + "company.company.logo.cache": { + "fields": { + "company": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "height": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "image": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": true, + "settable": true, + "type": "Binary" + }, + "width": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "company.company.tax_identifier": { + "fields": { + "company": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "company_party": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "country": { + "file": "company/company.py", + "module": "company", + "relation": "country.country", + "required": null, + "settable": true, + "type": "Many2One" + }, + "organization": { + "file": "company/company.py", + "module": "company", + "relation": "country.organization", + "required": null, + "settable": true, + "type": "Many2One" + }, + "tax_identifier": { + "file": "company/company.py", + "module": "company", + "relation": "party.identifier", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "company.employee": { + "fields": { + "active": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "company": { + "file": "company/company.py", + "module": "company", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "end_date": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "party": { + "file": "company/company.py", + "module": "company", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "start_date": { + "file": "company/company.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "subordinates": { + "file": "company/company.py", + "module": "company", + "relation": "company.employee", + "required": null, + "settable": true, + "type": "One2Many" + }, + "supervisor": { + "file": "company/company.py", + "module": "company", + "relation": "company.employee", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "country.country": { + "fields": { + "code": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code3": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code_numeric": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "flag": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "members": { + "file": "country/country.py", + "module": "country", + "relation": "country.organization.member", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "organizations": { + "file": "country/country.py", + "module": "country", + "relation": "country.organization.member", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "region": { + "file": "country/country.py", + "module": "country", + "relation": "country.region", + "required": null, + "settable": true, + "type": "Many2One" + }, + "subdivisions": { + "file": "country/country.py", + "module": "country", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "country.organization": { + "fields": { + "code": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "countries": { + "file": "country/country.py", + "module": "country", + "relation": "country.organization.member", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "members": { + "file": "country/country.py", + "module": "country", + "relation": "country.organization.member", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "country.organization.member": { + "fields": { + "active": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "country": { + "file": "country/country.py", + "module": "country", + "relation": "country.country", + "required": true, + "settable": true, + "type": "Many2One" + }, + "from_date": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "organization": { + "file": "country/country.py", + "module": "country", + "relation": "country.organization", + "required": true, + "settable": true, + "type": "Many2One" + }, + "to_date": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + } + }, + "persisted": true + }, + "country.postal_code": { + "fields": { + "city": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "country": { + "file": "country/country.py", + "module": "country", + "relation": "country.country", + "required": true, + "settable": true, + "type": "Many2One" + }, + "postal_code": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "subdivision": { + "file": "country/country.py", + "module": "country", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "country.region": { + "fields": { + "code_numeric": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "countries": { + "file": "country/country.py", + "module": "country", + "relation": "country.country", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "country/country.py", + "module": "country", + "relation": "country.region", + "required": null, + "settable": true, + "type": "Many2One" + }, + "subregions": { + "file": "country/country.py", + "module": "country", + "relation": "country.region", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "country.subdivision": { + "fields": { + "code": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "country": { + "file": "country/country.py", + "module": "country", + "relation": "country.country", + "required": true, + "settable": true, + "type": "Many2One" + }, + "flag": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "name": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "country/country.py", + "module": "country", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "country/country.py", + "module": "country", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "currency.cron": { + "fields": { + "currencies": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.cron-currency.currency", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "currency": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.currency", + "required": true, + "settable": true, + "type": "Many2One" + }, + "day": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "frequency": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "last_update": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "source": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "weekday": { + "file": "currency/currency.py", + "module": "currency", + "relation": "ir.calendar.day", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "currency.cron-currency.currency": { + "fields": { + "cron": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.cron", + "required": true, + "settable": true, + "type": "Many2One" + }, + "currency": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.currency", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "currency.currency": { + "fields": { + "code": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "digits": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "name": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "numeric_code": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "rate": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "rates": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.currency.rate", + "required": null, + "settable": true, + "type": "One2Many" + }, + "rounding": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Numeric" + }, + "symbol": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "currency.currency.rate": { + "fields": { + "currency": { + "file": "currency/currency.py", + "module": "currency", + "relation": "currency.currency", + "required": true, + "settable": true, + "type": "Many2One" + }, + "date": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "rate": { + "file": "currency/currency.py", + "module": "currency", + "relation": null, + "required": true, + "settable": true, + "type": "Numeric" + } + }, + "persisted": true + }, + "ir.action": { + "fields": { + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Reference]" + }, + "groups": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "icon": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.ui.icon", + "required": null, + "settable": true, + "type": "Many2One" + }, + "keywords": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.keyword", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "records": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "type": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "usage": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.action-res.group": { + "fields": { + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "group": { + "file": "ir/action.py", + "module": "ir", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.action.act_window": { + "fields": { + "act_window_domains": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window.domain", + "required": null, + "settable": true, + "type": "One2Many" + }, + "act_window_views": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window.view", + "required": null, + "settable": true, + "type": "One2Many" + }, + "context": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "context_domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "context_model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "domains": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Field]" + }, + "limit": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "order": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "pyson_context": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "pyson_domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "pyson_order": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "pyson_search_value": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "res_model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "search_value": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "views": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Field]" + } + }, + "persisted": true + }, + "ir.action.act_window.domain": { + "fields": { + "act_window": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window", + "required": true, + "settable": true, + "type": "Many2One" + }, + "count": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "domain": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.action.act_window.view": { + "fields": { + "act_window": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action.act_window", + "required": true, + "settable": true, + "type": "Many2One" + }, + "model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "view": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.ui.view", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.action.keyword": { + "fields": { + "action": { + "file": "ir/action.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "groups": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2Many]" + }, + "keyword": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "model": { + "file": "ir/action.py", + "module": "ir", + "relation": "Model", + "required": null, + "settable": true, + "type": "Reference" + } + }, + "persisted": true + }, + "ir.action.report": { + "fields": { + "direct_print": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "extension": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "is_custom": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "record_name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "report": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "report_content": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Binary]" + }, + "report_content_custom": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Binary" + }, + "report_content_html": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Text]" + }, + "report_content_name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "report_name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "single": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "template_extension": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "translatable": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.action.url": { + "fields": { + "url": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.action.wizard": { + "fields": { + "model": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "window": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "wiz_name": { + "file": "ir/action.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.attachment": { + "fields": { + "data": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Binary" + }, + "data_size": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "description": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "file_id": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "link": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "summary": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "type": { + "file": "ir/attachment.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.avatar": { + "fields": { + "cache": { + "file": "ir/avatar.py", + "module": "ir", + "relation": "ir.avatar.cache", + "required": null, + "settable": true, + "type": "One2Many" + }, + "uuid": { + "file": "ir/avatar.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.avatar.cache": { + "fields": { + "avatar": { + "file": "ir/avatar.py", + "module": "ir", + "relation": "ir.avatar", + "required": true, + "settable": true, + "type": "Many2One" + }, + "size": { + "file": "ir/avatar.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "ir.cache": { + "fields": { + "name": { + "file": "ir/cache.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "timestamp": { + "file": "ir/cache.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + } + }, + "persisted": true + }, + "ir.calendar.day": { + "fields": {}, + "persisted": false + }, + "ir.calendar.month": { + "fields": {}, + "persisted": false + }, + "ir.chat.channel": { + "fields": { + "followers": { + "file": "ir/chat.py", + "module": "ir", + "relation": "ir.chat.follower", + "required": null, + "settable": true, + "type": "One2Many" + }, + "identifier": { + "file": "ir/chat.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "resource": { + "file": "ir/chat.py", + "module": "ir", + "relation": "Resource", + "required": true, + "settable": true, + "type": "Reference" + } + }, + "persisted": true + }, + "ir.chat.follower": { + "fields": { + "channel": { + "file": "ir/chat.py", + "module": "ir", + "relation": "ir.chat.channel", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.chat.message": { + "fields": { + "audience": { + "file": "ir/chat.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "channel": { + "file": "ir/chat.py", + "module": "ir", + "relation": "ir.chat.channel", + "required": true, + "settable": true, + "type": "Many2One" + }, + "content": { + "file": "ir/chat.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Text" + }, + "reference": { + "file": "ir/chat.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "summary": { + "file": "ir/chat.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "ir.configuration": { + "fields": { + "currency_rate_decimal": { + "file": "currency/ir.py", + "module": "currency", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "hostname": { + "file": "ir/configuration.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "language": { + "file": "ir/configuration.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "product_price_decimal": { + "file": "product/ir.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "series": { + "file": "ir/configuration.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.cron": { + "fields": { + "companies": { + "file": "company/ir.py", + "module": "company", + "relation": "ir.cron-company.company", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "day": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "hour": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "interval_number": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "interval_type": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "logs": { + "file": "ir/cron.py", + "module": "ir", + "relation": "ir.cron.log", + "required": null, + "settable": true, + "type": "One2Many" + }, + "method": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "minute": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "next_call": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "DateTime" + }, + "running": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "timezone": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "weekday": { + "file": "ir/cron.py", + "module": "ir", + "relation": "ir.calendar.day", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.cron-company.company": { + "fields": { + "company": { + "file": "company/ir.py", + "module": "company", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "cron": { + "file": "company/ir.py", + "module": "company", + "relation": "ir.cron", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.cron.log": { + "fields": { + "cron": { + "file": "ir/cron.py", + "module": "ir", + "relation": "ir.cron", + "required": true, + "settable": true, + "type": "Many2One" + }, + "duration": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[TimeDelta]" + }, + "ended": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "DateTime" + }, + "started": { + "file": "ir/cron.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "DateTime" + } + }, + "persisted": true + }, + "ir.date": { + "fields": {}, + "persisted": false + }, + "ir.email": { + "fields": { + "addresses": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.email.address", + "required": null, + "settable": true, + "type": "One2Many" + }, + "at": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[DateTime]" + }, + "body": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "message_id": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "recipients": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "recipients_hidden": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "recipients_secondary": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "subject": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "user": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "ir.email.address": { + "fields": { + "address": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "email": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.email", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.email.template": { + "fields": { + "body": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "contact_mechanism": { + "file": "party/ir.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "model": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "model_name": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "name": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "recipients": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.model.field", + "required": null, + "settable": true, + "type": "Many2One" + }, + "recipients_hidden": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.model.field", + "required": null, + "settable": true, + "type": "Many2One" + }, + "recipients_hidden_pyson": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "recipients_pyson": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "recipients_secondary": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.model.field", + "required": null, + "settable": true, + "type": "Many2One" + }, + "recipients_secondary_pyson": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "reports": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.email.template-ir.action.report", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "subject": { + "file": "ir/email_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.email.template-ir.action.report": { + "fields": { + "report": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.action.report", + "required": true, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "ir/email_.py", + "module": "ir", + "relation": "ir.email.template", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.error": { + "fields": { + "description": { + "file": "ir/error.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "message": { + "file": "ir/error.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "origin": { + "file": "ir/error.py", + "module": "ir", + "relation": "Origin", + "required": null, + "settable": true, + "type": "Reference" + }, + "processed_by": { + "file": "ir/error.py", + "module": "ir", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + }, + "solved_by": { + "file": "ir/error.py", + "module": "ir", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + }, + "state": { + "file": "ir/error.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "summary": { + "file": "ir/error.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "ir.export": { + "fields": { + "export_fields": { + "file": "ir/export.py", + "module": "ir", + "relation": "ir.export.line", + "required": null, + "settable": true, + "type": "One2Many" + }, + "groups": { + "file": "ir/export.py", + "module": "ir", + "relation": "ir.export-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "header": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "ignore_search_limit": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "name": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "records": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "resource": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "user": { + "file": "ir/export.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + }, + "write_groups": { + "file": "ir/export.py", + "module": "ir", + "relation": "ir.export-write-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": true + }, + "ir.export-res.group": { + "fields": { + "export": { + "file": "ir/export.py", + "module": "ir", + "relation": "ir.export", + "required": true, + "settable": true, + "type": "Many2One" + }, + "group": { + "file": "ir/export.py", + "module": "ir", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.export-write-res.group": { + "fields": {}, + "persisted": false + }, + "ir.export.line": { + "fields": { + "export": { + "file": "ir/export.py", + "module": "ir", + "relation": "ir.export", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/export.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.filestore.queue": { + "fields": { + "field": { + "file": "ir/filestore.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "file_id": { + "file": "ir/filestore.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/filestore.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "prefix": { + "file": "ir/filestore.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.lang": { + "fields": { + "am": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "date": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "decimal_point": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "direction": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "grouping": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "mon_decimal_point": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "mon_grouping": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "mon_thousands_sep": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "n_cs_precedes": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "n_sep_by_space": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "n_sign_posn": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "name": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "negative_sign": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "nplurals": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "p_cs_precedes": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "p_sep_by_space": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "p_sign_posn": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "parent": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "pg_text_search": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "plural": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "pm": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "positive_sign": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "thousands_sep": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "translatable": { + "file": "ir/lang.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.lang.config": { + "fields": {}, + "persisted": false + }, + "ir.lang.config.start": { + "fields": { + "languages": { + "file": "ir/lang.py", + "module": "ir", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "ir.message": { + "fields": { + "text": { + "file": "ir/message.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Text" + }, + "text_plural": { + "file": "ir/message.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": true + }, + "ir.model": { + "fields": { + "fields": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.field", + "required": null, + "settable": true, + "type": "One2Many" + }, + "global_search_p": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "module": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "string": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.model.access": { + "fields": { + "description": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "group": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.group", + "required": null, + "settable": true, + "type": "Many2One" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "perm_create": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_delete": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_read": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_write": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.model.button": { + "fields": { + "clicks": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button.click", + "required": null, + "settable": true, + "type": "One2Many" + }, + "confirm": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "groups": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "help": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "reset": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button-button.reset", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "reset_by": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button-button.reset", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "rules": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button.rule", + "required": null, + "settable": true, + "type": "One2Many" + }, + "string": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.model.button-button.reset": { + "fields": { + "button": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "button_ruled": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.button-res.group": { + "fields": { + "button": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "group": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.button.click": { + "fields": { + "button": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "record_id": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "user": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.button.rule": { + "fields": { + "button": { + "file": "ir/model.py", + "module": "ir", + "relation": "ir.model.button", + "required": true, + "settable": true, + "type": "Many2One" + }, + "condition": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "description": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "group": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.group", + "required": null, + "settable": true, + "type": "Many2One" + }, + "number_user": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "ir.model.data": { + "fields": { + "db_id": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "field_names": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "MultiSelection" + }, + "fs_id": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "noupdate": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.model.field": { + "fields": { + "access": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "help": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "relation": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "string": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "ttype": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.model.field.access": { + "fields": { + "description": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "field": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "group": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.group", + "required": null, + "settable": true, + "type": "Many2One" + }, + "model": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "perm_create": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_delete": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_read": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_write": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.model.graph": { + "fields": {}, + "persisted": false + }, + "ir.model.log": { + "fields": { + "action": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "event": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "target": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "user": { + "file": "ir/model.py", + "module": "ir", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.model.print_model_graph": { + "fields": {}, + "persisted": false + }, + "ir.model.print_model_graph.start": { + "fields": { + "filter": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "level": { + "file": "ir/model.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + } + }, + "persisted": false + }, + "ir.model.refresh_materialized": { + "fields": {}, + "persisted": false + }, + "ir.model.workflow_graph": { + "fields": {}, + "persisted": false + }, + "ir.module": { + "fields": { + "childs": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2Many]" + }, + "dependencies": { + "file": "ir/module.py", + "module": "ir", + "relation": "ir.module.dependency", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parents": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2Many]" + }, + "state": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "version": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "ir.module.activate_upgrade": { + "fields": {}, + "persisted": false + }, + "ir.module.activate_upgrade.done": { + "fields": {}, + "persisted": false + }, + "ir.module.activate_upgrade.start": { + "fields": { + "module_info": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": false + }, + "ir.module.config": { + "fields": {}, + "persisted": false + }, + "ir.module.config.start": { + "fields": { + "modules": { + "file": "ir/module.py", + "module": "ir", + "relation": "ir.module", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "ir.module.config_wizard": { + "fields": {}, + "persisted": false + }, + "ir.module.config_wizard.done": { + "fields": {}, + "persisted": false + }, + "ir.module.config_wizard.first": { + "fields": {}, + "persisted": false + }, + "ir.module.config_wizard.item": { + "fields": { + "action": { + "file": "ir/module.py", + "module": "ir", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "state": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.module.config_wizard.other": { + "fields": { + "percentage": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + } + }, + "persisted": false + }, + "ir.module.dependency": { + "fields": { + "module": { + "file": "ir/module.py", + "module": "ir", + "relation": "ir.module", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "ir/module.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + } + }, + "persisted": true + }, + "ir.note": { + "fields": { + "message": { + "file": "ir/note.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "message_wrapped": { + "file": "ir/note.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Text]" + }, + "unread": { + "file": "ir/note.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Boolean]" + } + }, + "persisted": true + }, + "ir.note.read": { + "fields": { + "note": { + "file": "ir/note.py", + "module": "ir", + "relation": "ir.note", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "ir/note.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.queue": { + "fields": { + "data": { + "file": "ir/queue_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Dict" + }, + "dequeued_at": { + "file": "ir/queue_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "enqueued_at": { + "file": "ir/queue_.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Timestamp" + }, + "expected_at": { + "file": "ir/queue_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "finished_at": { + "file": "ir/queue_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "name": { + "file": "ir/queue_.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "scheduled_at": { + "file": "ir/queue_.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + } + }, + "persisted": true + }, + "ir.rule": { + "fields": { + "domain": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "rule_group": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.rule.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.rule.group": { + "fields": { + "default_p": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "global_p": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "groups": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.rule.group-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "model": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "perm_create": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_delete": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_read": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "perm_write": { + "file": "ir/rule.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "rules": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.rule", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "ir.rule.group-res.group": { + "fields": { + "group": { + "file": "ir/rule.py", + "module": "ir", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "rule_group": { + "file": "ir/rule.py", + "module": "ir", + "relation": "ir.rule.group", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.sequence": { + "fields": { + "company": { + "file": "company/ir.py", + "module": "company", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "last_timestamp": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "name": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "number_increment": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "number_next": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function" + }, + "number_next_internal": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "padding": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "prefix": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "preview": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "sequence_type": { + "file": "ir/sequence.py", + "module": "ir", + "relation": "ir.sequence.type", + "required": true, + "settable": true, + "type": "Many2One" + }, + "suffix": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "timestamp_offset": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "timestamp_rounding": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "type": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.sequence.strict": { + "fields": {}, + "persisted": false + }, + "ir.sequence.type": { + "fields": { + "groups": { + "file": "ir/sequence.py", + "module": "ir", + "relation": "ir.sequence.type-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "name": { + "file": "ir/sequence.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.sequence.type-res.group": { + "fields": { + "group": { + "file": "ir/sequence.py", + "module": "ir", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "sequence_type": { + "file": "ir/sequence.py", + "module": "ir", + "relation": "ir.sequence.type", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.session": { + "fields": { + "ip_address": { + "file": "ir/session.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "key": { + "file": "ir/session.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.session.wizard": { + "fields": { + "data": { + "file": "ir/session.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": true + }, + "ir.translation": { + "fields": { + "field": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "fuzzy": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "lang": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "model": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "module": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "overriding_module": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "res_id": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "src": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "src_plural": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "type": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "value": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "value_1": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "value_2": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "value_3": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + } + }, + "persisted": true + }, + "ir.translation.clean": { + "fields": {}, + "persisted": false + }, + "ir.translation.clean.start": { + "fields": {}, + "persisted": false + }, + "ir.translation.clean.succeed": { + "fields": {}, + "persisted": false + }, + "ir.translation.export": { + "fields": {}, + "persisted": false + }, + "ir.translation.export.result": { + "fields": { + "file": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Binary" + }, + "filename": { + "file": "ir/translation.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "language": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2One" + }, + "module": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.module", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "ir.translation.export.start": { + "fields": { + "language": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.lang", + "required": true, + "settable": true, + "type": "Many2One" + }, + "module": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.module", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "ir.translation.report": { + "fields": {}, + "persisted": false + }, + "ir.translation.set": { + "fields": {}, + "persisted": false + }, + "ir.translation.set.start": { + "fields": {}, + "persisted": false + }, + "ir.translation.set.succeed": { + "fields": {}, + "persisted": false + }, + "ir.translation.update": { + "fields": {}, + "persisted": false + }, + "ir.translation.update.start": { + "fields": { + "language": { + "file": "ir/translation.py", + "module": "ir", + "relation": "ir.lang", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "ir.trigger": { + "fields": { + "action": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "condition": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "limit_number": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "minimum_time_delay": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "TimeDelta" + }, + "model": { + "file": "ir/trigger.py", + "module": "ir", + "relation": "ir.model", + "required": true, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "on_create_": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "on_delete_": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "on_time_": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "on_write_": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "ir.trigger.log": { + "fields": { + "record_id": { + "file": "ir/trigger.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "trigger": { + "file": "ir/trigger.py", + "module": "ir", + "relation": "ir.trigger", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.icon": { + "fields": { + "icon": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Text]" + }, + "module": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "path": { + "file": "ir/ui/icon.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "ir.ui.menu": { + "fields": { + "action": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Reference]" + }, + "action_keywords": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.action.keyword", + "required": null, + "settable": true, + "type": "One2Many" + }, + "childs": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu", + "required": null, + "settable": true, + "type": "One2Many" + }, + "complete_name": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "favorite": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "favorites": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu.favorite", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "groups": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "icon": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "name": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.menu-res.group": { + "fields": { + "group": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "menu": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.menu.favorite": { + "fields": { + "menu": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "ir.ui.menu", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "ir/ui/menu.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.view": { + "fields": { + "arch": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Text]" + }, + "basis": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "data": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "domain": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "extensions": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "ir.ui.view", + "required": null, + "settable": true, + "type": "One2Many" + }, + "field_childs": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "inherit": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "ir.ui.view", + "required": null, + "settable": true, + "type": "Many2One" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "module": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "type": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "ir.ui.view.show": { + "fields": {}, + "persisted": false + }, + "ir.ui.view.show.start": { + "fields": {}, + "persisted": false + }, + "ir.ui.view_search": { + "fields": { + "domain": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "name": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "user": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.view_tree_optional": { + "fields": { + "field": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "user": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + }, + "value": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "view": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "ir.ui.view", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.view_tree_state": { + "fields": { + "child_name": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "domain": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "nodes": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "selected_nodes": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "user": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "ir.ui.view_tree_width": { + "fields": { + "field": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "model": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "occurrence": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "screen_width": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "user": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + }, + "width": { + "file": "ir/ui/view.py", + "module": "ir", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + } + }, + "persisted": true + }, + "party.address": { + "fields": { + "attn": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "building_name": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "building_number": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "city": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "contact_mechanisms": { + "file": "party/address.py", + "module": "party", + "relation": "party.contact_mechanism", + "required": null, + "settable": true, + "type": "One2Many" + }, + "country": { + "file": "party/address.py", + "module": "party", + "relation": "country.country", + "required": null, + "settable": true, + "type": "Many2One" + }, + "delivery": { + "file": "stock/party.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "floor_number": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "full_address": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Text]" + }, + "identifiers": { + "file": "party/address.py", + "module": "party", + "relation": "party.identifier", + "required": null, + "settable": true, + "type": "One2Many" + }, + "party": { + "file": "party/address.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "party_name": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "post_box": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "post_office": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "postal_code": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "private_bag": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "room_number": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "street": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Text]" + }, + "street_name": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "street_single_line": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "street_unstructured": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "subdivision": { + "file": "party/address.py", + "module": "party", + "relation": "country.subdivision", + "required": null, + "settable": true, + "type": "Many2One" + }, + "subdivision_types": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[MultiSelection]" + }, + "unit_number": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "warehouses": { + "file": "stock/party.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "party.address.format": { + "fields": { + "building_number_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "country_code": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "floor_number_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "format_": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Text" + }, + "language_code": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "post_box_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "post_office_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "private_bag_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "room_number_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "street_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Text" + }, + "unit_number_format": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "party.address.subdivision_type": { + "fields": { + "country_code": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "types": { + "file": "party/address.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiSelection" + } + }, + "persisted": true + }, + "party.category": { + "fields": { + "childs": { + "file": "party/category.py", + "module": "party", + "relation": "party.category", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "party/category.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "party/category.py", + "module": "party", + "relation": "party.category", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.check_vies": { + "fields": {}, + "persisted": false + }, + "party.check_vies.result": { + "fields": { + "parties_failed": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "parties_succeed": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "party.configuration": { + "fields": { + "identifier_types": { + "file": "party/configuration.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiSelection" + }, + "party_lang": { + "file": "party/configuration.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "party_sequence": { + "file": "party/configuration.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + } + }, + "persisted": true + }, + "party.configuration.party_lang": { + "fields": {}, + "persisted": true + }, + "party.configuration.party_sequence": { + "fields": {}, + "persisted": true + }, + "party.contact_mechanism": { + "fields": { + "address": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "comment": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "delivery": { + "file": "stock/party.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "email": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "language": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "languages": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": "party.contact_mechanism.language", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "other_value": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "party": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "sip": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "skype": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "type": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "url": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "value": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "value_compact": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "website": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "party.contact_mechanism.language": { + "fields": { + "contact_mechanism": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": "party.contact_mechanism", + "required": null, + "settable": true, + "type": "Many2One" + }, + "language": { + "file": "party/contact_mechanism.py", + "module": "party", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.erase": { + "fields": {}, + "persisted": false + }, + "party.erase.ask": { + "fields": { + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "party.identifier": { + "fields": { + "address": { + "file": "party/party.py", + "module": "party", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "code": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "code_compact": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "type_address": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + } + }, + "persisted": true + }, + "party.letter": { + "fields": {}, + "persisted": false + }, + "party.party": { + "fields": { + "addresses": { + "file": "party/party.py", + "module": "party", + "relation": "party.address", + "required": null, + "settable": true, + "type": "One2Many" + }, + "categories": { + "file": "party/party.py", + "module": "party", + "relation": "party.party-party.category", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "code": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "code_alnum": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code_digit": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "code_readonly": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "contact_mechanisms": { + "file": "party/party.py", + "module": "party", + "relation": "party.contact_mechanism", + "required": null, + "settable": true, + "type": "One2Many" + }, + "customer_location": { + "file": "stock/party.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "delivered_to_warehouses": { + "file": "stock/party.py", + "module": "stock", + "relation": "party.party-delivered_to-stock.location", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "distance": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "email": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "fax": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "full_name": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "identifiers": { + "file": "party/party.py", + "module": "party", + "relation": "party.identifier", + "required": null, + "settable": true, + "type": "One2Many" + }, + "lang": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "langs": { + "file": "party/party.py", + "module": "party", + "relation": "party.party.lang", + "required": null, + "settable": true, + "type": "One2Many" + }, + "locations": { + "file": "stock/party.py", + "module": "stock", + "relation": "party.party.location", + "required": null, + "settable": true, + "type": "One2Many" + }, + "mobile": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "name": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "phone": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "replaced_by": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2One" + }, + "supplier_location": { + "file": "stock/party.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "tax_identifier": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "website": { + "file": "party/party.py", + "module": "party", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + } + }, + "persisted": true + }, + "party.party-delivered_to-stock.location": { + "fields": { + "location": { + "file": "stock/party.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "party": { + "file": "stock/party.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.party-party.category": { + "fields": { + "category": { + "file": "party/party.py", + "module": "party", + "relation": "party.category", + "required": true, + "settable": true, + "type": "Many2One" + }, + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.party.lang": { + "fields": { + "lang": { + "file": "party/party.py", + "module": "party", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2One" + }, + "party": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.party.location": { + "fields": { + "party": { + "file": "stock/party.py", + "module": "stock", + "relation": "party.party", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "party.replace": { + "fields": {}, + "persisted": false + }, + "party.replace.ask": { + "fields": { + "destination": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "source": { + "file": "party/party.py", + "module": "party", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "product.by_location.context": { + "fields": { + "company": { + "file": "stock/product.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "forecast_date": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "stock_date_end": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Date]" + } + }, + "persisted": false + }, + "product.category": { + "fields": { + "childs": { + "file": "product/category.py", + "module": "product", + "relation": "product.category", + "required": null, + "settable": true, + "type": "One2Many" + }, + "code": { + "file": "product/category.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code_readonly": { + "file": "product/category.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "name": { + "file": "product/category.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "product/category.py", + "module": "product", + "relation": "product.category", + "required": null, + "settable": true, + "type": "Many2One" + }, + "templates": { + "file": "product/category.py", + "module": "product", + "relation": "product.template-product.category", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": true + }, + "product.configuration": { + "fields": { + "category_sequence": { + "file": "product/configuration.py", + "module": "product", + "relation": "ir.sequence", + "required": null, + "settable": true, + "type": "Many2One" + }, + "default_cost_price_method": { + "file": "product/configuration.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "default_lot_sequence": { + "file": "stock_lot/product.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "product_sequence": { + "file": "product/configuration.py", + "module": "product", + "relation": "ir.sequence", + "required": null, + "settable": true, + "type": "Many2One" + }, + "template_sequence": { + "file": "product/configuration.py", + "module": "product", + "relation": "ir.sequence", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.configuration.default_cost_price_method": { + "fields": {}, + "persisted": true + }, + "product.configuration.default_lot_sequence": { + "fields": { + "default_lot_sequence": { + "file": "stock_lot/product.py", + "module": "stock_lot", + "relation": "ir.sequence", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.cost_price": { + "fields": { + "cost_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Numeric" + }, + "product": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.cost_price.revision": { + "fields": { + "company": { + "file": "stock/product.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock/product.py", + "module": "stock", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "stock/product.py", + "module": "stock", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.cost_price_method": { + "fields": { + "cost_price_method": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.identifier": { + "fields": { + "code": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "product": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "product.list_price": { + "fields": { + "list_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "product": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.modify_cost_price": { + "fields": {}, + "persisted": false + }, + "product.modify_cost_price.start": { + "fields": { + "cost_price": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "date": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + } + }, + "persisted": false + }, + "product.price_list": { + "fields": {}, + "persisted": false + }, + "product.price_list.line": { + "fields": { + "volume_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "weight_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "product.product": { + "fields": { + "boms": { + "file": "production/product.py", + "module": "production", + "relation": "product.product-production.bom", + "required": null, + "settable": true, + "type": "One2Many" + }, + "code": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code_readonly": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "cost_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "cost_price_uom": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "cost_prices": { + "file": "product/product.py", + "module": "product", + "relation": "product.cost_price", + "required": null, + "settable": true, + "type": "One2Many" + }, + "cost_value": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "description": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "forecast_quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "identifiers": { + "file": "product/product.py", + "module": "product", + "relation": "product.identifier", + "required": null, + "settable": true, + "type": "One2Many" + }, + "list_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "list_price_uom": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "list_price_used": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "list_prices": { + "file": "product/product.py", + "module": "product", + "relation": "product.list_price", + "required": null, + "settable": true, + "type": "One2Many" + }, + "locations": { + "file": "stock_product_location/product.py", + "module": "stock_product_location", + "relation": "stock.product.location", + "required": null, + "settable": true, + "type": "One2Many" + }, + "position": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "prefix_code": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "production_lead_times": { + "file": "production/product.py", + "module": "production", + "relation": "production.lead_time", + "required": null, + "settable": true, + "type": "One2Many" + }, + "quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "replaced_by": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "suffix_code": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.product-production.bom": { + "fields": { + "bom": { + "file": "production/product.py", + "module": "production", + "relation": "production.bom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "production/product.py", + "module": "production", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.product.replace": { + "fields": {}, + "persisted": false + }, + "product.product.replace.ask": { + "fields": { + "destination": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "source": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "source_default_uom_category": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "source_type": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + } + }, + "persisted": false + }, + "product.recompute_cost_price": { + "fields": {}, + "persisted": false + }, + "product.recompute_cost_price.start": { + "fields": { + "from_": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + } + }, + "persisted": false + }, + "product.template": { + "fields": { + "categories": { + "file": "product/product.py", + "module": "product", + "relation": "product.template-product.category", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "categories_all": { + "file": "product/product.py", + "module": "product", + "relation": "product.template-product.category.all", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "code": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code_readonly": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "consumable": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "cost_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "cost_price_method": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "cost_price_methods": { + "file": "product/product.py", + "module": "product", + "relation": "product.cost_price_method", + "required": null, + "settable": true, + "type": "One2Many" + }, + "cost_value": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "default_uom": { + "file": "product/product.py", + "module": "product", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "default_uom_category": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "expiration_state": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "expiration_time": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "forecast_quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "height": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "height_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "length": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "length_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "list_price": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "list_prices": { + "file": "product/product.py", + "module": "product", + "relation": "product.list_price", + "required": null, + "settable": true, + "type": "One2Many" + }, + "locations": { + "file": "stock_product_location/product.py", + "module": "stock_product_location", + "relation": "stock.product.location", + "required": null, + "settable": true, + "type": "One2Many" + }, + "lot_required": { + "file": "stock_lot/product.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "MultiSelection" + }, + "lot_sequence": { + "file": "stock_lot/product.py", + "module": "stock_lot", + "relation": "ir.sequence", + "required": null, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "producible": { + "file": "production/product.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "products": { + "file": "product/product.py", + "module": "product", + "relation": "product.product", + "required": null, + "settable": true, + "type": "One2Many" + }, + "quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "shelf_life_state": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "shelf_life_time": { + "file": "stock_lot_sled/product.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "type": { + "file": "product/product.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "volume": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "volume_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "weight": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "weight_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "width": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "width_uom": { + "file": "product_measurements/product.py", + "module": "product_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.template-product.category": { + "fields": { + "category": { + "file": "product/product.py", + "module": "product", + "relation": "product.category", + "required": true, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.template-product.category.all": { + "fields": { + "category": { + "file": "product/product.py", + "module": "product", + "relation": "product.category", + "required": null, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "product/product.py", + "module": "product", + "relation": "product.template", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "product.uom": { + "fields": { + "category": { + "file": "product/uom.py", + "module": "product", + "relation": "product.uom.category", + "required": true, + "settable": true, + "type": "Many2One" + }, + "digits": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "factor": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "name": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "rate": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "rounding": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "symbol": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "product.uom.category": { + "fields": { + "name": { + "file": "product/uom.py", + "module": "product", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "uoms": { + "file": "product/uom.py", + "module": "product", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "production": { + "fields": { + "bom": { + "file": "production/production.py", + "module": "production", + "relation": "production.bom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "company": { + "file": "production/production.py", + "module": "production", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "cost": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "effective_start_date": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "inputs": { + "file": "production/production.py", + "module": "production", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "location": { + "file": "production/production.py", + "module": "production", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "number": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "origin": { + "file": "production/production.py", + "module": "production", + "relation": "Origin", + "required": null, + "settable": true, + "type": "Reference" + }, + "outputs": { + "file": "production/production.py", + "module": "production", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "planned_start_date": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "product": { + "file": "production/production.py", + "module": "production", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "state": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "type": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "unit": { + "file": "production/production.py", + "module": "production", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "production/production.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse": { + "file": "production/production.py", + "module": "production", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "production.bom": { + "fields": { + "code": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "code_readonly": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "input_products": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.input", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "inputs": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.input", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "output_products": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.output", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "outputs": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.output", + "required": null, + "settable": true, + "type": "One2Many" + }, + "phantom": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "phantom_quantity": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "phantom_unit": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "production.bom.input": { + "fields": { + "bom": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "phantom_bom": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "production.bom.output": { + "fields": {}, + "persisted": false + }, + "production.bom.tree": { + "fields": { + "childs": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.tree", + "required": null, + "settable": true, + "type": "One2Many" + }, + "product": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "production.bom.tree.open": { + "fields": {}, + "persisted": false + }, + "production.bom.tree.open.start": { + "fields": { + "bom": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product-production.bom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "category": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom.category", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "production/bom.py", + "module": "production", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "production/bom.py", + "module": "production", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "production/bom.py", + "module": "production", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "production.bom.tree.open.tree": { + "fields": { + "bom_tree": { + "file": "production/bom.py", + "module": "production", + "relation": "production.bom.tree", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": false + }, + "production.configuration": { + "fields": { + "bom_sequence": { + "file": "production/configuration.py", + "module": "production", + "relation": "ir.sequence", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_sequence": { + "file": "production/configuration.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + } + }, + "persisted": true + }, + "production.configuration.production_sequence": { + "fields": { + "production_sequence": { + "file": "production/configuration.py", + "module": "production", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "production.lead_time": { + "fields": { + "bom": { + "file": "production/product.py", + "module": "production", + "relation": "production.bom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "lead_time": { + "file": "production/product.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "TimeDelta" + }, + "product": { + "file": "production/product.py", + "module": "production", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "production.split": { + "fields": {}, + "persisted": false + }, + "production.split.start": { + "fields": { + "count": { + "file": "production_split/production.py", + "module": "production_split", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "quantity": { + "file": "production_split/production.py", + "module": "production_split", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "production_split/production.py", + "module": "production_split", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "production_split/production.py", + "module": "production_split", + "relation": "product.uom.category", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "res.group": { + "fields": { + "buttons": { + "file": "res/group.py", + "module": "res", + "relation": "ir.model.button-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "field_access": { + "file": "res/group.py", + "module": "res", + "relation": "ir.model.field.access", + "required": null, + "settable": true, + "type": "One2Many" + }, + "model_access": { + "file": "res/group.py", + "module": "res", + "relation": "ir.model.access", + "required": null, + "settable": true, + "type": "One2Many" + }, + "name": { + "file": "res/group.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "parent": { + "file": "res/group.py", + "module": "res", + "relation": "res.group", + "required": null, + "settable": true, + "type": "Many2One" + }, + "rule_groups": { + "file": "res/group.py", + "module": "res", + "relation": "ir.rule.group-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "users": { + "file": "res/group.py", + "module": "res", + "relation": "res.user-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": true + }, + "res.notification": { + "fields": { + "action": { + "file": "res/notification.py", + "module": "res", + "relation": "ir.action", + "required": null, + "settable": true, + "type": "Many2One" + }, + "action_value": { + "file": "res/notification.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "description": { + "file": "res/notification.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "icon": { + "file": "res/notification.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "label": { + "file": "res/notification.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "model": { + "file": "res/notification.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "records": { + "file": "res/notification.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "unread": { + "file": "res/notification.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "user": { + "file": "res/notification.py", + "module": "res", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user": { + "fields": { + "actions": { + "file": "res/user.py", + "module": "res", + "relation": "res.user-ir.action", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "applications": { + "file": "res/user.py", + "module": "res", + "relation": "res.user.application", + "required": null, + "settable": true, + "type": "One2Many" + }, + "avatar_badge_url": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "companies": { + "file": "company/res.py", + "module": "company", + "relation": "res.user-company.company", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "company": { + "file": "company/res.py", + "module": "company", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "company_filter": { + "file": "company/res.py", + "module": "company", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "email": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "employee": { + "file": "company/res.py", + "module": "company", + "relation": "company.employee", + "required": null, + "settable": true, + "type": "Many2One" + }, + "employees": { + "file": "company/res.py", + "module": "company", + "relation": "res.user-company.employee", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "groups": { + "file": "res/user.py", + "module": "res", + "relation": "res.user-res.group", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "language": { + "file": "res/user.py", + "module": "res", + "relation": "ir.lang", + "required": null, + "settable": true, + "type": "Many2One" + }, + "language_direction": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "login": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "menu": { + "file": "res/user.py", + "module": "res", + "relation": "ir.action", + "required": null, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "notifications": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "MultiSelection" + }, + "password": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Function[Char]" + }, + "password_hash": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "password_reset": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "password_reset_expire": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Timestamp" + }, + "pyson_menu": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "sessions": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Integer]" + }, + "signature": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Text" + }, + "status_bar": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "warehouse": { + "file": "stock/res.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "warnings": { + "file": "res/user.py", + "module": "res", + "relation": "res.user.warning", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": true + }, + "res.user-company.company": { + "fields": { + "company": { + "file": "company/res.py", + "module": "company", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "company/res.py", + "module": "company", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user-company.employee": { + "fields": { + "employee": { + "file": "company/res.py", + "module": "company", + "relation": "company.employee", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "company/res.py", + "module": "company", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user-ir.action": { + "fields": { + "action": { + "file": "res/user.py", + "module": "res", + "relation": "ir.action", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user-res.group": { + "fields": { + "group": { + "file": "res/user.py", + "module": "res", + "relation": "res.group", + "required": true, + "settable": true, + "type": "Many2One" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user.application": { + "fields": { + "application": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "key": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "state": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "res.user.config": { + "fields": {}, + "persisted": false + }, + "res.user.config.start": { + "fields": {}, + "persisted": false + }, + "res.user.device": { + "fields": { + "cookie": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "login": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "res.user.email_reset_password": { + "fields": {}, + "persisted": false + }, + "res.user.login.attempt": { + "fields": { + "device_cookie": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "ip_address": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "ip_network": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "login": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + } + }, + "persisted": true + }, + "res.user.warning": { + "fields": { + "always": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "name": { + "file": "res/user.py", + "module": "res", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "user": { + "file": "res/user.py", + "module": "res", + "relation": "res.user", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.configuration": { + "fields": { + "inventory_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "measurement_volume_uom": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "measurement_weight_uom": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shelf_life_delay": { + "file": "stock_lot_sled/stock.py", + "module": "stock_lot_sled", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_in_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_in_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_internal_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_internal_transit": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_out_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + }, + "shipment_out_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "MultiValue" + } + }, + "persisted": true + }, + "stock.configuration.location": { + "fields": {}, + "persisted": true + }, + "stock.configuration.measurement": { + "fields": { + "measurement_volume_uom": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "measurement_weight_uom": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.configuration.sequence": { + "fields": { + "inventory_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_in_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_in_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_internal_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_out_return_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + }, + "shipment_out_sequence": { + "file": "stock/configuration.py", + "module": "stock", + "relation": "ir.sequence", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.inventory": { + "fields": { + "company": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "date": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "empty_quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "lines": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.inventory.line", + "required": null, + "settable": true, + "type": "One2Many" + }, + "location": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "number": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "state": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "stock.inventory.count": { + "fields": {}, + "persisted": false + }, + "stock.inventory.count.quantity": { + "fields": { + "line": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.inventory.line", + "required": true, + "settable": true, + "type": "Many2One" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "total_quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "stock.inventory.count.search": { + "fields": { + "search": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "Search", + "required": true, + "settable": true, + "type": "Reference" + } + }, + "persisted": false + }, + "stock.inventory.line": { + "fields": { + "expected_quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "inventory": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.inventory", + "required": true, + "settable": true, + "type": "Many2One" + }, + "inventory_date": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Date]" + }, + "inventory_location": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "inventory_state": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Selection]" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "moves": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "product": { + "file": "stock/inventory.py", + "module": "stock", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "stock/inventory.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.location": { + "fields": { + "address": { + "file": "stock/location.py", + "module": "stock", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "allow_pickup": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "childs": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "One2Many" + }, + "code": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Char" + }, + "cost_value": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "flat_childs": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "forecast_quantity": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "input_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "left": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "lost_found_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "name": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Char" + }, + "output_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "parent": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "picking_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_location": { + "file": "production/stock.py", + "module": "production", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_output_location": { + "file": "production/stock.py", + "module": "production", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_picking_location": { + "file": "production/stock.py", + "module": "production", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "quantity_uom": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "right": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Integer" + }, + "storage_location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "type": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "warehouse": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "waste_locations": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location.waste", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "waste_warehouses": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location.waste", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": true + }, + "stock.location.lead_time": { + "fields": { + "lead_time": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "TimeDelta" + }, + "warehouse_from": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "warehouse_to": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.location.lot.shelf_life": { + "fields": {}, + "persisted": true + }, + "stock.location.waste": { + "fields": { + "location": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse": { + "file": "stock/location.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.lot": { + "fields": { + "default_uom": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "forecast_quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + } + }, + "persisted": true + }, + "stock.lot.trace": { + "fields": { + "company": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "date": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "document": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "Document", + "required": null, + "settable": true, + "type": "Reference" + }, + "downward_traces": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2Many]" + }, + "from_location": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_input": { + "file": "production/stock.py", + "module": "production", + "relation": "production", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_output": { + "file": "production/stock.py", + "module": "production", + "relation": "production", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "to_location": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "unit": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "upward_traces": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2Many]" + } + }, + "persisted": true + }, + "stock.lots_by_location.context": { + "fields": { + "forecast_date": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "stock_date_end": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Date]" + } + }, + "persisted": false + }, + "stock.lots_by_locations": { + "fields": { + "default_uom": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "forecast_quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + } + }, + "persisted": true + }, + "stock.move": { + "fields": { + "assignation_required": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "company": { + "file": "stock/move.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "cost_price": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "cost_price_required": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "currency": { + "file": "stock/move.py", + "module": "stock", + "relation": "currency.currency", + "required": null, + "settable": true, + "type": "Many2One" + }, + "delay": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[TimeDelta]" + }, + "effective_date": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "from_location": { + "file": "stock/move.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "from_location_name": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "internal_quantity": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "internal_volume": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "internal_weight": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "origin": { + "file": "stock/move.py", + "module": "stock", + "relation": "Origin", + "required": null, + "settable": true, + "type": "Reference" + }, + "origin_planned_date": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "outcome_moves": { + "file": "stock/move.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "planned_date": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "product": { + "file": "stock/move.py", + "module": "stock", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product_cost_price": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "product_uom_category": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "production": { + "file": "production/stock.py", + "module": "production", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "production_cost_price_updated": { + "file": "production/stock.py", + "module": "production", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "production_input": { + "file": "production/stock.py", + "module": "production", + "relation": "production", + "required": null, + "settable": true, + "type": "Many2One" + }, + "production_output": { + "file": "production/stock.py", + "module": "production", + "relation": "production", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "shipment": { + "file": "stock/move.py", + "module": "stock", + "relation": "Shipment", + "required": null, + "settable": true, + "type": "Reference" + }, + "state": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "to_location": { + "file": "stock/move.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "to_location_name": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "unit": { + "file": "stock/move.py", + "module": "stock", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "unit_price": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Numeric" + }, + "unit_price_company": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "unit_price_required": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "unit_price_updated": { + "file": "stock/move.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + } + }, + "persisted": true + }, + "stock.move.add.lots": { + "fields": {}, + "persisted": false + }, + "stock.move.add.lots.start": { + "fields": { + "duplicate_lot_number": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "lots": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.move.add.lots.start.lot", + "required": null, + "settable": true, + "type": "One2Many" + }, + "product": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "quantity_remaining": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "unit": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "stock.move.add.lots.start.lot": { + "fields": { + "parent": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.move.add.lots.start", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "quantity_unit": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": false + }, + "stock.move.split": { + "fields": {}, + "persisted": false + }, + "stock.move.split.start": { + "fields": { + "count": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": null, + "required": null, + "settable": true, + "type": "Integer" + }, + "quantity": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": null, + "required": true, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "product.uom", + "required": true, + "settable": true, + "type": "Many2One" + }, + "uom_category": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "product.uom.category", + "required": null, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "stock.package": { + "fields": { + "additional_weight": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "additional_weight_uom": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": "product.uom", + "required": null, + "settable": true, + "type": "Many2One" + }, + "total_volume": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "total_weight": { + "file": "stock_shipment_measurements/stock.py", + "module": "stock_shipment_measurements", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + } + }, + "persisted": false + }, + "stock.period": { + "fields": { + "caches": { + "file": "stock/period.py", + "module": "stock", + "relation": "stock.period.cache", + "required": null, + "settable": true, + "type": "One2Many" + }, + "company": { + "file": "stock/period.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "date": { + "file": "stock/period.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "lot_caches": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.period.cache.lot", + "required": null, + "settable": true, + "type": "One2Many" + }, + "state": { + "file": "stock/period.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + } + }, + "persisted": true + }, + "stock.period.cache": { + "fields": { + "internal_quantity": { + "file": "stock/period.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "location": { + "file": "stock/period.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "period": { + "file": "stock/period.py", + "module": "stock", + "relation": "stock.period", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock/period.py", + "module": "stock", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.period.cache.lot": { + "fields": { + "internal_quantity": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "location": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "lot": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.lot", + "required": null, + "settable": true, + "type": "Many2One" + }, + "period": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "stock.period", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock_lot/stock.py", + "module": "stock_lot", + "relation": "product.product", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.product.location": { + "fields": { + "location": { + "file": "stock_product_location/location.py", + "module": "stock_product_location", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock_product_location/location.py", + "module": "stock_product_location", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "template": { + "file": "stock_product_location/location.py", + "module": "stock_product_location", + "relation": "product.template", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse": { + "file": "stock_product_location/location.py", + "module": "stock_product_location", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.product_quantities_warehouse": { + "fields": { + "company": { + "file": "stock/product.py", + "module": "stock", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product": { + "file": "stock/product.py", + "module": "stock", + "relation": "Product", + "required": null, + "settable": true, + "type": "Reference" + }, + "quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + } + }, + "persisted": true + }, + "stock.product_quantities_warehouse.context": { + "fields": { + "company": { + "file": "stock/product.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "stock_skip_warehouse": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "warehouse": { + "file": "stock/product.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": false + }, + "stock.product_quantities_warehouse.move": { + "fields": { + "company": { + "file": "stock/product.py", + "module": "stock", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "cumulative_quantity_delta": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "cumulative_quantity_end": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "cumulative_quantity_start": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "date": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "document": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Reference]" + }, + "move": { + "file": "stock/product.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2One" + }, + "origin": { + "file": "stock/product.py", + "module": "stock", + "relation": "Origin", + "required": null, + "settable": true, + "type": "Reference" + }, + "product": { + "file": "stock/product.py", + "module": "stock", + "relation": "Product", + "required": null, + "settable": true, + "type": "Reference" + }, + "quantity": { + "file": "stock/product.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + } + }, + "persisted": true + }, + "stock.product_quantities_warehouse.move.open": { + "fields": {}, + "persisted": false + }, + "stock.product_quantities_warehouse.open": { + "fields": {}, + "persisted": false + }, + "stock.products_by_locations": { + "fields": { + "consumable": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Boolean]" + }, + "cost_value": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Numeric]" + }, + "default_uom": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "forecast_quantity": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + }, + "product": { + "file": "stock/location.py", + "module": "stock", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "quantity": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Float]" + } + }, + "persisted": true + }, + "stock.products_by_locations.context": { + "fields": { + "company": { + "file": "stock/location.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "forecast_date": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "stock_date_end": { + "file": "stock/location.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Date]" + } + }, + "persisted": false + }, + "stock.reporting.inventory": { + "fields": {}, + "persisted": true + }, + "stock.reporting.inventory.context": { + "fields": { + "date": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Date" + }, + "product_type": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + } + }, + "persisted": false + }, + "stock.reporting.inventory.daily": { + "fields": { + "from_date": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "to_date": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + } + }, + "persisted": true + }, + "stock.reporting.inventory.move": { + "fields": { + "date": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "document": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Reference]" + }, + "move": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2One" + }, + "origin": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": "Origin", + "required": null, + "settable": true, + "type": "Reference" + } + }, + "persisted": true + }, + "stock.reporting.inventory.range.context": { + "fields": {}, + "persisted": false + }, + "stock.reporting.inventory.turnover": { + "fields": { + "average_quantity": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "company": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": "company.company", + "required": null, + "settable": true, + "type": "Many2One" + }, + "output_quantity": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "product": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": "product.product", + "required": null, + "settable": true, + "type": "Many2One" + }, + "product_reference": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": "Product", + "required": null, + "settable": true, + "type": "Reference" + }, + "product_template": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": "product.template", + "required": null, + "settable": true, + "type": "Many2One" + }, + "turnover": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Float" + }, + "unit": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.reporting.inventory.turnover.context": { + "fields": { + "product_type": { + "file": "stock/stock_reporting.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + } + }, + "persisted": false + }, + "stock.reporting.margin.category": { + "fields": { + "time_series": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": "stock.reporting.margin.category.time_series", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": false + }, + "stock.reporting.margin.category.time_series": { + "fields": {}, + "persisted": false + }, + "stock.reporting.margin.category.tree": { + "fields": { + "children": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": "stock.reporting.margin.category.tree", + "required": null, + "settable": true, + "type": "One2Many" + }, + "cost": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function" + }, + "currency": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "margin": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function" + }, + "name": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "parent": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": "stock.reporting.margin.category.tree", + "required": null, + "settable": true, + "type": "Many2One" + }, + "profit": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function" + }, + "revenue": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function" + } + }, + "persisted": true + }, + "stock.reporting.margin.context": { + "fields": { + "company": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "from_date": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "include_lost": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Boolean" + }, + "period": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": true, + "settable": true, + "type": "Selection" + }, + "to_date": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + } + }, + "persisted": false + }, + "stock.reporting.margin.main": { + "fields": { + "time_series": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2Many]" + } + }, + "persisted": false + }, + "stock.reporting.margin.main.time_series": { + "fields": {}, + "persisted": false + }, + "stock.reporting.margin.product": { + "fields": { + "time_series": { + "file": "stock/stock_reporting_margin.py", + "module": "stock", + "relation": "stock.reporting.margin.product.time_series", + "required": null, + "settable": true, + "type": "One2Many" + } + }, + "persisted": false + }, + "stock.reporting.margin.product.time_series": { + "fields": {}, + "persisted": false + }, + "stock.shipment.assign": { + "fields": {}, + "persisted": false + }, + "stock.shipment.assign.partial": { + "fields": { + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + }, + "stock.shipment.drop": { + "fields": {}, + "persisted": false + }, + "stock.shipment.in": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "contact_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "incoming_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "inventory_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "supplier": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "supplier_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_input": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_storage": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.shipment.in.restocking_list": { + "fields": {}, + "persisted": false + }, + "stock.shipment.in.return": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "delivery_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "from_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "supplier": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "to_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.shipment.internal": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "effective_start_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "from_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "incoming_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "internal_transit_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": null, + "settable": true, + "type": "Many2One" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "outgoing_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "planned_start_date": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Date" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "to_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "to_warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "transit_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + } + }, + "persisted": true + }, + "stock.shipment.internal.report": { + "fields": {}, + "persisted": false + }, + "stock.shipment.out": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "customer": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "customer_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "delivery_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": true, + "settable": true, + "type": "Many2One" + }, + "inventory_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "outgoing_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_output": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_storage": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.shipment.out.delivery_note": { + "fields": {}, + "persisted": false + }, + "stock.shipment.out.picking_list": { + "fields": {}, + "persisted": false + }, + "stock.shipment.out.return": { + "fields": { + "company": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "company.company", + "required": true, + "settable": true, + "type": "Many2One" + }, + "contact_address": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.address", + "required": null, + "settable": true, + "type": "Many2One" + }, + "customer": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "party.party", + "required": true, + "settable": true, + "type": "Many2One" + }, + "customer_location": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Many2One]" + }, + "incoming_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "inventory_moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Function[One2Many]" + }, + "moves": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "One2Many" + }, + "origins": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": false, + "type": "Function[Char]" + }, + "state": { + "file": "stock/shipment.py", + "module": "stock", + "relation": null, + "required": null, + "settable": true, + "type": "Selection" + }, + "warehouse": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_input": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + }, + "warehouse_storage": { + "file": "stock/shipment.py", + "module": "stock", + "relation": "stock.location", + "required": true, + "settable": true, + "type": "Many2One" + } + }, + "persisted": true + }, + "stock.shipment.out.return.restocking_list": { + "fields": {}, + "persisted": false + }, + "stock.shipment.split": { + "fields": {}, + "persisted": false + }, + "stock.shipment.split.start": { + "fields": { + "domain_moves": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + }, + "moves": { + "file": "stock_split/stock.py", + "module": "stock_split", + "relation": "stock.move", + "required": null, + "settable": true, + "type": "Many2Many" + } + }, + "persisted": false + } +} \ No newline at end of file diff --git a/reports/model_tree_8.0.md b/reports/model_tree_8.0.md new file mode 100644 index 0000000..511f9cd --- /dev/null +++ b/reports/model_tree_8.0.md @@ -0,0 +1,1656 @@ +# Modellbaum (ir, res, company, country, currency, party, product, product_measurements, production, production_split, stock, stock_lot, stock_lot_sled, stock_product_location, stock_shipment_measurements, stock_split) + + +## `company.company` _(Felder aus: company)_ + +- **currency**: Many2One -> `currency.currency` required +- **employees**: One2Many -> `company.employee` +- **footer**: Text +- **header**: Text +- **logo**: Binary +- **logo_cache**: One2Many -> `company.company.logo.cache` +- **party**: Many2One -> `party.party` required +- **tax_identifiers**: One2Many -> `company.company.tax_identifier` +- **timezone**: Selection + +## `company.company.logo.cache` _(Felder aus: company)_ + +- **company**: Many2One -> `company.company` required +- **height**: Integer required +- **image**: Binary required +- **width**: Integer required + +## `company.company.tax_identifier` _(Felder aus: company)_ + +- **company**: Many2One -> `company.company` required +- **company_party**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **country**: Many2One -> `country.country` +- **organization**: Many2One -> `country.organization` +- **tax_identifier**: Many2One -> `party.identifier` + +## `company.employee` _(Felder aus: company)_ + +- **active**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **company**: Many2One -> `company.company` required +- **end_date**: Date +- **party**: Many2One -> `party.party` required +- **start_date**: Date +- **subordinates**: One2Many -> `company.employee` +- **supervisor**: Many2One -> `company.employee` + +## `country.country` _(Felder aus: country)_ + +- **code**: Char +- **code3**: Char +- **code_numeric**: Char +- **flag**: Function[Char] NICHT setzbar (Function ohne setter) +- **members**: One2Many -> `country.organization.member` +- **name**: Char required +- **organizations**: Many2Many -> `country.organization.member` +- **region**: Many2One -> `country.region` +- **subdivisions**: One2Many -> `country.subdivision` + +## `country.organization` _(Felder aus: country)_ + +- **code**: Char +- **countries**: Many2Many -> `country.organization.member` +- **members**: One2Many -> `country.organization.member` +- **name**: Char required + +## `country.organization.member` _(Felder aus: country)_ + +- **active**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **country**: Many2One -> `country.country` required +- **from_date**: Date +- **organization**: Many2One -> `country.organization` required +- **to_date**: Date + +## `country.postal_code` _(Felder aus: country)_ + +- **city**: Char +- **country**: Many2One -> `country.country` required +- **postal_code**: Char +- **subdivision**: Many2One -> `country.subdivision` + +## `country.region` _(Felder aus: country)_ + +- **code_numeric**: Char +- **countries**: One2Many -> `country.country` +- **name**: Char required +- **parent**: Many2One -> `country.region` +- **subregions**: One2Many -> `country.region` + +## `country.subdivision` _(Felder aus: country)_ + +- **code**: Char +- **country**: Many2One -> `country.country` required +- **flag**: Function[Char] NICHT setzbar (Function ohne setter) +- **name**: Char required +- **parent**: Many2One -> `country.subdivision` +- **type**: Selection + +## `currency.cron` _(Felder aus: currency)_ + +- **currencies**: Many2Many -> `currency.cron-currency.currency` +- **currency**: Many2One -> `currency.currency` required +- **day**: Integer +- **frequency**: Selection required +- **last_update**: Date required +- **source**: Selection required +- **weekday**: Many2One -> `ir.calendar.day` + +## `currency.cron-currency.currency` _(Felder aus: currency)_ + +- **cron**: Many2One -> `currency.cron` required +- **currency**: Many2One -> `currency.currency` required + +## `currency.currency` _(Felder aus: currency)_ + +- **code**: Char required +- **digits**: Integer required +- **name**: Char required +- **numeric_code**: Char +- **rate**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **rates**: One2Many -> `currency.currency.rate` +- **rounding**: Numeric required +- **symbol**: Char + +## `currency.currency.rate` _(Felder aus: currency)_ + +- **currency**: Many2One -> `currency.currency` required +- **date**: Date required +- **rate**: Numeric required + +## `ir.action` _(Felder aus: ir)_ + +- **action**: Function[Reference] NICHT setzbar (Function ohne setter) +- **groups**: Many2Many -> `ir.action-res.group` +- **icon**: Many2One -> `ir.ui.icon` +- **keywords**: One2Many -> `ir.action.keyword` +- **name**: Char required +- **records**: Selection +- **type**: Selection required +- **usage**: Char + +## `ir.action-res.group` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` required +- **group**: Many2One -> `res.group` required + +## `ir.action.act_window` _(Felder aus: ir)_ + +- **act_window_domains**: One2Many -> `ir.action.act_window.domain` +- **act_window_views**: One2Many -> `ir.action.act_window.view` +- **context**: Char +- **context_domain**: Char +- **context_model**: Char +- **domain**: Char +- **domains**: Function[Field] NICHT setzbar (Function ohne setter) +- **limit**: Integer +- **order**: Char +- **pyson_context**: Function[Char] NICHT setzbar (Function ohne setter) +- **pyson_domain**: Function[Char] NICHT setzbar (Function ohne setter) +- **pyson_order**: Function[Char] NICHT setzbar (Function ohne setter) +- **pyson_search_value**: Function[Char] NICHT setzbar (Function ohne setter) +- **res_model**: Char +- **search_value**: Char +- **views**: Function[Field] NICHT setzbar (Function ohne setter) + +## `ir.action.act_window.domain` _(Felder aus: ir)_ + +- **act_window**: Many2One -> `ir.action.act_window` required +- **count**: Boolean +- **domain**: Char +- **name**: Char + +## `ir.action.act_window.view` _(Felder aus: ir)_ + +- **act_window**: Many2One -> `ir.action.act_window` required +- **model**: Function[Char] NICHT setzbar (Function ohne setter) +- **view**: Many2One -> `ir.ui.view` required + +## `ir.action.keyword` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` required +- **groups**: Function[Many2Many] NICHT setzbar (Function ohne setter) +- **keyword**: Selection required +- **model**: Reference -> `Model` + +## `ir.action.report` _(Felder aus: ir)_ + +- **direct_print**: Boolean +- **extension**: Selection +- **is_custom**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **model**: Char +- **module**: Char +- **record_name**: Char +- **report**: Char +- **report_content**: Function[Binary] +- **report_content_custom**: Binary +- **report_content_html**: Function[Text] +- **report_content_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **report_name**: Char required +- **single**: Boolean +- **template_extension**: Selection required +- **translatable**: Boolean + +## `ir.action.url` _(Felder aus: ir)_ + +- **url**: Char required + +## `ir.action.wizard` _(Felder aus: ir)_ + +- **model**: Char +- **window**: Boolean +- **wiz_name**: Char required + +## `ir.attachment` _(Felder aus: ir)_ + +- **data**: Binary +- **data_size**: Function[Integer] NICHT setzbar (Function ohne setter) +- **description**: Text +- **file_id**: Char +- **link**: Char +- **name**: Char required +- **summary**: Function[Char] NICHT setzbar (Function ohne setter) +- **type**: Selection required + +## `ir.avatar` _(Felder aus: ir)_ + +- **cache**: One2Many -> `ir.avatar.cache` +- **uuid**: Char required + +## `ir.avatar.cache` _(Felder aus: ir)_ + +- **avatar**: Many2One -> `ir.avatar` required +- **size**: Integer required + +## `ir.cache` _(Felder aus: ir)_ + +- **name**: Char required +- **timestamp**: Timestamp + +## `ir.chat.channel` _(Felder aus: ir)_ + +- **followers**: One2Many -> `ir.chat.follower` +- **identifier**: Char +- **resource**: Reference -> `Resource` required + +## `ir.chat.follower` _(Felder aus: ir)_ + +- **channel**: Many2One -> `ir.chat.channel` required + +## `ir.chat.message` _(Felder aus: ir)_ + +- **audience**: Selection required +- **channel**: Many2One -> `ir.chat.channel` required +- **content**: Text required +- **reference**: Char +- **summary**: Function[Char] NICHT setzbar (Function ohne setter) + +## `ir.configuration` _(Felder aus: currency, ir, product)_ + +- **currency_rate_decimal**: Integer (aus Modul `currency`) +- **hostname**: Char +- **language**: Char +- **product_price_decimal**: Integer (aus Modul `product`) +- **series**: Char + +## `ir.cron` _(Felder aus: company, ir)_ + +- **companies**: Many2Many -> `ir.cron-company.company` (aus Modul `company`) +- **day**: Integer +- **hour**: Integer +- **interval_number**: Integer required +- **interval_type**: Selection required +- **logs**: One2Many -> `ir.cron.log` +- **method**: Selection required +- **minute**: Integer +- **next_call**: DateTime +- **running**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **timezone**: Function[Char] NICHT setzbar (Function ohne setter) +- **weekday**: Many2One -> `ir.calendar.day` + +## `ir.cron-company.company` _(Felder aus: company)_ + +- **company**: Many2One -> `company.company` required (aus Modul `company`) +- **cron**: Many2One -> `ir.cron` required (aus Modul `company`) + +## `ir.cron.log` _(Felder aus: ir)_ + +- **cron**: Many2One -> `ir.cron` required +- **duration**: Function[TimeDelta] NICHT setzbar (Function ohne setter) +- **ended**: DateTime required +- **started**: DateTime required + +## `ir.email` _(Felder aus: ir)_ + +- **addresses**: One2Many -> `ir.email.address` +- **at**: Function[DateTime] NICHT setzbar (Function ohne setter) +- **body**: Text +- **message_id**: Char +- **recipients**: Char +- **recipients_hidden**: Char +- **recipients_secondary**: Char +- **subject**: Char +- **user**: Function[Char] NICHT setzbar (Function ohne setter) + +## `ir.email.address` _(Felder aus: ir)_ + +- **address**: Char required +- **email**: Many2One -> `ir.email` required + +## `ir.email.template` _(Felder aus: ir, party)_ + +- **body**: Text +- **contact_mechanism**: Selection (aus Modul `party`) +- **model**: Many2One -> `ir.model` required +- **model_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **name**: Char required +- **recipients**: Many2One -> `ir.model.field` +- **recipients_hidden**: Many2One -> `ir.model.field` +- **recipients_hidden_pyson**: Char +- **recipients_pyson**: Char +- **recipients_secondary**: Many2One -> `ir.model.field` +- **recipients_secondary_pyson**: Char +- **reports**: Many2Many -> `ir.email.template-ir.action.report` +- **subject**: Char + +## `ir.email.template-ir.action.report` _(Felder aus: ir)_ + +- **report**: Many2One -> `ir.action.report` required +- **template**: Many2One -> `ir.email.template` required + +## `ir.error` _(Felder aus: ir)_ + +- **description**: Text +- **message**: Text +- **origin**: Reference -> `Origin` +- **processed_by**: Many2One -> `res.user` +- **solved_by**: Many2One -> `res.user` +- **state**: Selection +- **summary**: Function[Char] NICHT setzbar (Function ohne setter) + +## `ir.export` _(Felder aus: ir)_ + +- **export_fields**: One2Many -> `ir.export.line` +- **groups**: Many2Many -> `ir.export-res.group` +- **header**: Boolean +- **ignore_search_limit**: Boolean +- **name**: Char +- **records**: Selection +- **resource**: Char +- **user**: Many2One -> `res.user` required +- **write_groups**: Many2Many -> `ir.export-write-res.group` + +## `ir.export-res.group` _(Felder aus: ir)_ + +- **export**: Many2One -> `ir.export` required +- **group**: Many2One -> `res.group` required + +## `ir.export.line` _(Felder aus: ir)_ + +- **export**: Many2One -> `ir.export` required +- **name**: Char + +## `ir.filestore.queue` _(Felder aus: ir)_ + +- **field**: Char required +- **file_id**: Char required +- **model**: Char required +- **prefix**: Char + +## `ir.lang` _(Felder aus: ir)_ + +- **am**: Char +- **code**: Char required +- **date**: Char required +- **decimal_point**: Char required +- **direction**: Selection required +- **grouping**: Char required +- **mon_decimal_point**: Char required +- **mon_grouping**: Char required +- **mon_thousands_sep**: Char +- **n_cs_precedes**: Boolean +- **n_sep_by_space**: Boolean +- **n_sign_posn**: Integer required +- **name**: Char required +- **negative_sign**: Char +- **nplurals**: Integer required +- **p_cs_precedes**: Boolean +- **p_sep_by_space**: Boolean +- **p_sign_posn**: Integer required +- **parent**: Char +- **pg_text_search**: Char +- **plural**: Char required +- **pm**: Char +- **positive_sign**: Char +- **thousands_sep**: Char +- **translatable**: Boolean + +## `ir.lang.config.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **languages**: Many2Many -> `ir.lang` + +## `ir.message` _(Felder aus: ir)_ + +- **text**: Text required +- **text_plural**: Text + +## `ir.model` _(Felder aus: ir)_ + +- **fields**: One2Many -> `ir.model.field` +- **global_search_p**: Boolean +- **module**: Char +- **name**: Char required +- **string**: Char + +## `ir.model.access` _(Felder aus: ir)_ + +- **description**: Text +- **group**: Many2One -> `res.group` +- **model**: Char required +- **perm_create**: Boolean +- **perm_delete**: Boolean +- **perm_read**: Boolean +- **perm_write**: Boolean + +## `ir.model.button` _(Felder aus: ir)_ + +- **clicks**: One2Many -> `ir.model.button.click` +- **confirm**: Text +- **groups**: Many2Many -> `ir.model.button-res.group` +- **help**: Text +- **model**: Char required +- **name**: Char required +- **reset**: Many2Many -> `ir.model.button-button.reset` +- **reset_by**: Many2Many -> `ir.model.button-button.reset` +- **rules**: One2Many -> `ir.model.button.rule` +- **string**: Char + +## `ir.model.button-button.reset` _(Felder aus: ir)_ + +- **button**: Many2One -> `ir.model.button` required +- **button_ruled**: Many2One -> `ir.model.button` required + +## `ir.model.button-res.group` _(Felder aus: ir)_ + +- **button**: Many2One -> `ir.model.button` required +- **group**: Many2One -> `res.group` required + +## `ir.model.button.click` _(Felder aus: ir)_ + +- **button**: Many2One -> `ir.model.button` required +- **record_id**: Integer required +- **user**: Many2One -> `res.user` + +## `ir.model.button.rule` _(Felder aus: ir)_ + +- **button**: Many2One -> `ir.model.button` required +- **condition**: Char +- **description**: Char +- **group**: Many2One -> `res.group` +- **number_user**: Integer required + +## `ir.model.data` _(Felder aus: ir)_ + +- **db_id**: Integer +- **field_names**: MultiSelection +- **fs_id**: Char required +- **model**: Char required +- **module**: Char required +- **noupdate**: Boolean + +## `ir.model.field` _(Felder aus: ir)_ + +- **access**: Boolean +- **help**: Text +- **model**: Char required +- **module**: Char +- **name**: Char required +- **relation**: Char +- **string**: Char +- **ttype**: Char + +## `ir.model.field.access` _(Felder aus: ir)_ + +- **description**: Text +- **field**: Char required +- **group**: Many2One -> `res.group` +- **model**: Char required +- **perm_create**: Boolean +- **perm_delete**: Boolean +- **perm_read**: Boolean +- **perm_write**: Boolean + +## `ir.model.log` _(Felder aus: ir)_ + +- **action**: Function[Char] NICHT setzbar (Function ohne setter) +- **event**: Selection required +- **target**: Char +- **user**: Many2One -> `res.user` + +## `ir.model.print_model_graph.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **filter**: Text +- **level**: Integer required + +## `ir.module` _(Felder aus: ir)_ + +- **childs**: Function[Many2Many] NICHT setzbar (Function ohne setter) +- **dependencies**: One2Many -> `ir.module.dependency` +- **name**: Char required +- **parents**: Function[Many2Many] NICHT setzbar (Function ohne setter) +- **state**: Selection +- **version**: Function[Char] NICHT setzbar (Function ohne setter) + +## `ir.module.activate_upgrade.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **module_info**: Text + +## `ir.module.config.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **modules**: Many2Many -> `ir.module` + +## `ir.module.config_wizard.item` _(Felder aus: ir)_ + +- **action**: Many2One -> `ir.action` required +- **state**: Selection required + +## `ir.module.config_wizard.other` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **percentage**: Float + +## `ir.module.dependency` _(Felder aus: ir)_ + +- **module**: Many2One -> `ir.module` required +- **name**: Char +- **state**: Function[Selection] NICHT setzbar (Function ohne setter) + +## `ir.note` _(Felder aus: ir)_ + +- **message**: Text +- **message_wrapped**: Function[Text] NICHT setzbar (Function ohne setter) +- **unread**: Function[Boolean] + +## `ir.note.read` _(Felder aus: ir)_ + +- **note**: Many2One -> `ir.note` required +- **user**: Many2One -> `res.user` required + +## `ir.queue` _(Felder aus: ir)_ + +- **data**: Dict +- **dequeued_at**: Timestamp +- **enqueued_at**: Timestamp required +- **expected_at**: Timestamp +- **finished_at**: Timestamp +- **name**: Char required +- **scheduled_at**: Timestamp + +## `ir.rule` _(Felder aus: ir)_ + +- **domain**: Char required +- **rule_group**: Many2One -> `ir.rule.group` required + +## `ir.rule.group` _(Felder aus: ir)_ + +- **default_p**: Boolean +- **global_p**: Boolean +- **groups**: Many2Many -> `ir.rule.group-res.group` +- **model**: Char required +- **name**: Char required +- **perm_create**: Boolean +- **perm_delete**: Boolean +- **perm_read**: Boolean +- **perm_write**: Boolean +- **rules**: One2Many -> `ir.rule` + +## `ir.rule.group-res.group` _(Felder aus: ir)_ + +- **group**: Many2One -> `res.group` required +- **rule_group**: Many2One -> `ir.rule.group` required + +## `ir.sequence` _(Felder aus: company, ir)_ + +- **company**: Many2One -> `company.company` (aus Modul `company`) +- **last_timestamp**: Integer +- **name**: Char required +- **number_increment**: Integer +- **number_next**: Function NICHT setzbar (Function ohne setter) +- **number_next_internal**: Integer +- **padding**: Integer +- **prefix**: Char +- **preview**: Function[Char] NICHT setzbar (Function ohne setter) +- **sequence_type**: Many2One -> `ir.sequence.type` required +- **suffix**: Char +- **timestamp_offset**: Float required +- **timestamp_rounding**: Float required +- **type**: Selection + +## `ir.sequence.type` _(Felder aus: ir)_ + +- **groups**: Many2Many -> `ir.sequence.type-res.group` +- **name**: Char required + +## `ir.sequence.type-res.group` _(Felder aus: ir)_ + +- **group**: Many2One -> `res.group` required +- **sequence_type**: Many2One -> `ir.sequence.type` required + +## `ir.session` _(Felder aus: ir)_ + +- **ip_address**: Char +- **key**: Char required + +## `ir.session.wizard` _(Felder aus: ir)_ + +- **data**: Text + +## `ir.translation` _(Felder aus: ir)_ + +- **field**: Function[Char] NICHT setzbar (Function ohne setter) +- **fuzzy**: Boolean +- **lang**: Selection +- **model**: Function[Char] NICHT setzbar (Function ohne setter) +- **module**: Char +- **name**: Char required +- **overriding_module**: Char +- **res_id**: Integer required +- **src**: Text +- **src_plural**: Text +- **type**: Selection required +- **value**: Text +- **value_1**: Text +- **value_2**: Text +- **value_3**: Text + +## `ir.translation.export.result` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **file**: Binary +- **filename**: Char +- **language**: Many2One -> `ir.lang` +- **module**: Many2One -> `ir.module` + +## `ir.translation.export.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **language**: Many2One -> `ir.lang` required +- **module**: Many2One -> `ir.module` required + +## `ir.translation.update.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: ir)_ + +- **language**: Many2One -> `ir.lang` required + +## `ir.trigger` _(Felder aus: ir)_ + +- **action**: Selection required +- **condition**: Char required +- **limit_number**: Integer required +- **minimum_time_delay**: TimeDelta +- **model**: Many2One -> `ir.model` required +- **name**: Char required +- **on_create_**: Boolean +- **on_delete_**: Boolean +- **on_time_**: Boolean +- **on_write_**: Boolean + +## `ir.trigger.log` _(Felder aus: ir)_ + +- **record_id**: Integer required +- **trigger**: Many2One -> `ir.trigger` required + +## `ir.ui.icon` _(Felder aus: ir)_ + +- **icon**: Function[Text] NICHT setzbar (Function ohne setter) +- **module**: Char required +- **name**: Char required +- **path**: Char required + +## `ir.ui.menu` _(Felder aus: ir)_ + +- **action**: Function[Reference] +- **action_keywords**: One2Many -> `ir.action.keyword` +- **childs**: One2Many -> `ir.ui.menu` +- **complete_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **favorite**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **favorites**: Many2Many -> `ir.ui.menu.favorite` +- **groups**: Many2Many -> `ir.ui.menu-res.group` +- **icon**: Selection +- **name**: Char required +- **parent**: Many2One -> `ir.ui.menu` + +## `ir.ui.menu-res.group` _(Felder aus: ir)_ + +- **group**: Many2One -> `res.group` required +- **menu**: Many2One -> `ir.ui.menu` required + +## `ir.ui.menu.favorite` _(Felder aus: ir)_ + +- **menu**: Many2One -> `ir.ui.menu` required +- **user**: Many2One -> `res.user` required + +## `ir.ui.view` _(Felder aus: ir)_ + +- **arch**: Function[Text] +- **basis**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **data**: Text +- **domain**: Char +- **extensions**: One2Many -> `ir.ui.view` +- **field_childs**: Char +- **inherit**: Many2One -> `ir.ui.view` +- **model**: Char +- **module**: Char +- **name**: Char +- **type**: Selection + +## `ir.ui.view_search` _(Felder aus: ir)_ + +- **domain**: Char +- **model**: Char required +- **name**: Char required +- **user**: Many2One -> `res.user` + +## `ir.ui.view_tree_optional` _(Felder aus: ir)_ + +- **field**: Char required +- **model**: Char required +- **user**: Many2One -> `res.user` required +- **value**: Boolean +- **view**: Many2One -> `ir.ui.view` required + +## `ir.ui.view_tree_state` _(Felder aus: ir)_ + +- **child_name**: Char +- **domain**: Char required +- **model**: Char required +- **nodes**: Text +- **selected_nodes**: Text +- **user**: Many2One -> `res.user` required + +## `ir.ui.view_tree_width` _(Felder aus: ir)_ + +- **field**: Char required +- **model**: Char required +- **occurrence**: Integer required +- **screen_width**: Integer +- **user**: Many2One -> `res.user` required +- **width**: Integer + +## `party.address` _(Felder aus: party, stock)_ + +- **attn**: Char +- **building_name**: Char +- **building_number**: Char +- **city**: Char +- **contact_mechanisms**: One2Many -> `party.contact_mechanism` +- **country**: Many2One -> `country.country` +- **delivery**: Boolean (aus Modul `stock`) +- **floor_number**: Char +- **full_address**: Function[Text] NICHT setzbar (Function ohne setter) +- **identifiers**: One2Many -> `party.identifier` +- **party**: Many2One -> `party.party` required +- **party_name**: Char +- **post_box**: Char +- **post_office**: Char +- **postal_code**: Char +- **private_bag**: Char +- **room_number**: Char +- **street**: Function[Text] +- **street_name**: Char +- **street_single_line**: Function[Char] NICHT setzbar (Function ohne setter) +- **street_unstructured**: Text +- **subdivision**: Many2One -> `country.subdivision` +- **subdivision_types**: Function[MultiSelection] NICHT setzbar (Function ohne setter) +- **unit_number**: Char +- **warehouses**: One2Many -> `stock.location` (aus Modul `stock`) + +## `party.address.format` _(Felder aus: party)_ + +- **building_number_format**: Char +- **country_code**: Char +- **floor_number_format**: Char +- **format_**: Text required +- **language_code**: Char +- **post_box_format**: Char +- **post_office_format**: Char +- **private_bag_format**: Char +- **room_number_format**: Char +- **street_format**: Text required +- **unit_number_format**: Char + +## `party.address.subdivision_type` _(Felder aus: party)_ + +- **country_code**: Char required +- **types**: MultiSelection + +## `party.category` _(Felder aus: party)_ + +- **childs**: One2Many -> `party.category` +- **name**: Char required +- **parent**: Many2One -> `party.category` + +## `party.check_vies.result` _(Wizard/Transient - nicht persistent)_ _(Felder aus: party)_ + +- **parties_failed**: Many2Many -> `party.party` +- **parties_succeed**: Many2Many -> `party.party` + +## `party.configuration` _(Felder aus: party)_ + +- **identifier_types**: MultiSelection +- **party_lang**: MultiValue +- **party_sequence**: MultiValue + +## `party.contact_mechanism` _(Felder aus: party, stock)_ + +- **address**: Many2One -> `party.address` +- **comment**: Text +- **delivery**: Boolean (aus Modul `stock`) +- **email**: Function[Char] +- **language**: MultiValue +- **languages**: One2Many -> `party.contact_mechanism.language` +- **name**: Char +- **other_value**: Function[Char] +- **party**: Many2One -> `party.party` required +- **sip**: Function[Char] +- **skype**: Function[Char] +- **type**: Selection required +- **url**: Function[Char] NICHT setzbar (Function ohne setter) +- **value**: Char required +- **value_compact**: Char +- **website**: Function[Char] + +## `party.contact_mechanism.language` _(Felder aus: party)_ + +- **contact_mechanism**: Many2One -> `party.contact_mechanism` +- **language**: Many2One -> `ir.lang` + +## `party.erase.ask` _(Wizard/Transient - nicht persistent)_ _(Felder aus: party)_ + +- **party**: Many2One -> `party.party` required + +## `party.identifier` _(Felder aus: party)_ + +- **address**: Many2One -> `party.address` +- **code**: Char required +- **code_compact**: Char required +- **party**: Many2One -> `party.party` required +- **type**: Selection +- **type_address**: Function[Boolean] NICHT setzbar (Function ohne setter) + +## `party.party` _(Felder aus: party, stock)_ + +- **addresses**: One2Many -> `party.address` +- **categories**: Many2Many -> `party.party-party.category` +- **code**: Char required +- **code_alnum**: Char +- **code_digit**: Integer +- **code_readonly**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **contact_mechanisms**: One2Many -> `party.contact_mechanism` +- **customer_location**: MultiValue (aus Modul `stock`) +- **delivered_to_warehouses**: Many2Many -> `party.party-delivered_to-stock.location` (aus Modul `stock`) +- **distance**: Function[Integer] NICHT setzbar (Function ohne setter) +- **email**: Function[Char] +- **fax**: Function[Char] +- **full_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **identifiers**: One2Many -> `party.identifier` +- **lang**: MultiValue +- **langs**: One2Many -> `party.party.lang` +- **locations**: One2Many -> `party.party.location` (aus Modul `stock`) +- **mobile**: Function[Char] +- **name**: Char +- **phone**: Function[Char] +- **replaced_by**: Many2One -> `party.party` +- **supplier_location**: MultiValue (aus Modul `stock`) +- **tax_identifier**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **website**: Function[Char] + +## `party.party-delivered_to-stock.location` _(Felder aus: stock)_ + +- **location**: Many2One -> `stock.location` required (aus Modul `stock`) +- **party**: Many2One -> `party.party` required (aus Modul `stock`) + +## `party.party-party.category` _(Felder aus: party)_ + +- **category**: Many2One -> `party.category` required +- **party**: Many2One -> `party.party` required + +## `party.party.lang` _(Felder aus: party)_ + +- **lang**: Many2One -> `ir.lang` +- **party**: Many2One -> `party.party` + +## `party.party.location` _(Felder aus: stock)_ + +- **party**: Many2One -> `party.party` (aus Modul `stock`) + +## `party.replace.ask` _(Wizard/Transient - nicht persistent)_ _(Felder aus: party)_ + +- **destination**: Many2One -> `party.party` required +- **source**: Many2One -> `party.party` required + +## `product.by_location.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required (aus Modul `stock`) +- **forecast_date**: Date (aus Modul `stock`) +- **stock_date_end**: Function[Date] NICHT setzbar (Function ohne setter) (aus Modul `stock`) + +## `product.category` _(Felder aus: product)_ + +- **childs**: One2Many -> `product.category` +- **code**: Char +- **code_readonly**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **name**: Char required +- **parent**: Many2One -> `product.category` +- **templates**: Many2Many -> `product.template-product.category` + +## `product.configuration` _(Felder aus: product, stock_lot)_ + +- **category_sequence**: Many2One -> `ir.sequence` +- **default_cost_price_method**: MultiValue +- **default_lot_sequence**: MultiValue (aus Modul `stock_lot`) +- **product_sequence**: Many2One -> `ir.sequence` +- **template_sequence**: Many2One -> `ir.sequence` + +## `product.configuration.default_lot_sequence` _(Felder aus: stock_lot)_ + +- **default_lot_sequence**: Many2One -> `ir.sequence` (aus Modul `stock_lot`) + +## `product.cost_price` _(Felder aus: product)_ + +- **cost_price**: Numeric required +- **product**: Many2One -> `product.product` + +## `product.cost_price.revision` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required (aus Modul `stock`) +- **product**: Many2One -> `product.product` (aus Modul `stock`) +- **template**: Many2One -> `product.template` required (aus Modul `stock`) + +## `product.cost_price_method` _(Felder aus: product)_ + +- **cost_price_method**: Selection +- **template**: Many2One -> `product.template` + +## `product.identifier` _(Felder aus: product)_ + +- **code**: Char required +- **product**: Many2One -> `product.product` required +- **type**: Selection + +## `product.list_price` _(Felder aus: product)_ + +- **list_price**: Numeric +- **product**: Many2One -> `product.product` +- **template**: Many2One -> `product.template` required + +## `product.modify_cost_price.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **cost_price**: Char required (aus Modul `stock`) +- **date**: Date required (aus Modul `stock`) + +## `product.price_list.line` _(Wizard/Transient - nicht persistent)_ _(Felder aus: product_measurements)_ + +- **volume_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **weight_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) + +## `product.product` _(Felder aus: product, production, stock, stock_product_location)_ + +- **boms**: One2Many -> `product.product-production.bom` (aus Modul `production`) +- **code**: Char +- **code_readonly**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **cost_price**: MultiValue +- **cost_price_uom**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **cost_prices**: One2Many -> `product.cost_price` +- **cost_value**: Function[Numeric] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **description**: Text +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **identifiers**: One2Many -> `product.identifier` +- **list_price**: MultiValue +- **list_price_uom**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **list_price_used**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **list_prices**: One2Many -> `product.list_price` +- **locations**: One2Many -> `stock.product.location` (aus Modul `stock_product_location`) +- **position**: Integer +- **prefix_code**: Function[Char] NICHT setzbar (Function ohne setter) +- **production_lead_times**: One2Many -> `production.lead_time` (aus Modul `production`) +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **replaced_by**: Many2One -> `product.product` +- **suffix_code**: Char +- **template**: Many2One -> `product.template` required + +## `product.product-production.bom` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` required (aus Modul `production`) +- **product**: Many2One -> `product.product` required (aus Modul `production`) + +## `product.product.replace.ask` _(Wizard/Transient - nicht persistent)_ _(Felder aus: product)_ + +- **destination**: Many2One -> `product.product` required +- **source**: Many2One -> `product.product` required +- **source_default_uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **source_type**: Function[Selection] NICHT setzbar (Function ohne setter) + +## `product.recompute_cost_price.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **from_**: Date (aus Modul `stock`) + +## `product.template` _(Felder aus: product, product_measurements, production, stock, stock_lot, stock_lot_sled, stock_product_location)_ + +- **categories**: Many2Many -> `product.template-product.category` +- **categories_all**: Many2Many -> `product.template-product.category.all` +- **code**: Char +- **code_readonly**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **consumable**: Boolean +- **cost_price**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **cost_price_method**: MultiValue +- **cost_price_methods**: One2Many -> `product.cost_price_method` +- **cost_value**: Function[Numeric] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **default_uom**: Many2One -> `product.uom` required +- **default_uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **expiration_state**: Selection (aus Modul `stock_lot_sled`) +- **expiration_time**: Integer (aus Modul `stock_lot_sled`) +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **height**: Float (aus Modul `product_measurements`) +- **height_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **length**: Float (aus Modul `product_measurements`) +- **length_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **list_price**: MultiValue +- **list_prices**: One2Many -> `product.list_price` +- **locations**: One2Many -> `stock.product.location` (aus Modul `stock_product_location`) +- **lot_required**: MultiSelection (aus Modul `stock_lot`) +- **lot_sequence**: Many2One -> `ir.sequence` (aus Modul `stock_lot`) +- **name**: Char required +- **producible**: Boolean (aus Modul `production`) +- **products**: One2Many -> `product.product` +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock`) +- **shelf_life_state**: Selection (aus Modul `stock_lot_sled`) +- **shelf_life_time**: Integer (aus Modul `stock_lot_sled`) +- **type**: Selection required +- **volume**: Float (aus Modul `product_measurements`) +- **volume_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **weight**: Float (aus Modul `product_measurements`) +- **weight_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) +- **width**: Float (aus Modul `product_measurements`) +- **width_uom**: Many2One -> `product.uom` (aus Modul `product_measurements`) + +## `product.template-product.category` _(Felder aus: product)_ + +- **category**: Many2One -> `product.category` required +- **template**: Many2One -> `product.template` required + +## `product.template-product.category.all` _(Felder aus: product)_ + +- **category**: Many2One -> `product.category` +- **template**: Many2One -> `product.template` + +## `product.uom` _(Felder aus: product)_ + +- **category**: Many2One -> `product.uom.category` required +- **digits**: Integer required +- **factor**: Float required +- **name**: Char required +- **rate**: Float required +- **rounding**: Float required +- **symbol**: Char required + +## `product.uom.category` _(Felder aus: product)_ + +- **name**: Char required +- **uoms**: One2Many -> `product.uom` + +## `production` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` +- **company**: Many2One -> `company.company` required +- **cost**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **effective_start_date**: Date +- **inputs**: One2Many -> `stock.move` +- **location**: Many2One -> `stock.location` required +- **number**: Char +- **origin**: Reference -> `Origin` +- **outputs**: One2Many -> `stock.move` +- **planned_start_date**: Date +- **product**: Many2One -> `product.product` +- **quantity**: Float +- **state**: Selection +- **type**: Selection required +- **unit**: Many2One -> `product.uom` +- **uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse**: Many2One -> `stock.location` required + +## `production.bom` _(Felder aus: production)_ + +- **code**: Char +- **code_readonly**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **input_products**: Many2Many -> `production.bom.input` +- **inputs**: One2Many -> `production.bom.input` +- **name**: Char required +- **output_products**: Many2Many -> `production.bom.output` +- **outputs**: One2Many -> `production.bom.output` +- **phantom**: Boolean +- **phantom_quantity**: Float +- **phantom_unit**: Many2One -> `product.uom` + +## `production.bom.input` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` required +- **phantom_bom**: Many2One -> `production.bom` +- **product**: Many2One -> `product.product` +- **quantity**: Float required +- **unit**: Many2One -> `product.uom` required +- **uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `production.bom.tree` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production)_ + +- **childs**: One2Many -> `production.bom.tree` +- **product**: Many2One -> `product.product` +- **quantity**: Float +- **unit**: Many2One -> `product.uom` + +## `production.bom.tree.open.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production)_ + +- **bom**: Many2One -> `product.product-production.bom` required +- **category**: Many2One -> `product.uom.category` +- **product**: Many2One -> `product.product` +- **quantity**: Float required +- **unit**: Many2One -> `product.uom` required + +## `production.bom.tree.open.tree` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production)_ + +- **bom_tree**: One2Many -> `production.bom.tree` + +## `production.configuration` _(Felder aus: production)_ + +- **bom_sequence**: Many2One -> `ir.sequence` +- **production_sequence**: MultiValue + +## `production.configuration.production_sequence` _(Felder aus: production)_ + +- **production_sequence**: Many2One -> `ir.sequence` required + +## `production.lead_time` _(Felder aus: production)_ + +- **bom**: Many2One -> `production.bom` +- **lead_time**: TimeDelta +- **product**: Many2One -> `product.product` required + +## `production.split.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: production_split)_ + +- **count**: Integer (aus Modul `production_split`) +- **quantity**: Float required (aus Modul `production_split`) +- **unit**: Many2One -> `product.uom` required (aus Modul `production_split`) +- **uom_category**: Many2One -> `product.uom.category` (aus Modul `production_split`) + +## `res.group` _(Felder aus: res)_ + +- **buttons**: Many2Many -> `ir.model.button-res.group` +- **field_access**: One2Many -> `ir.model.field.access` +- **model_access**: One2Many -> `ir.model.access` +- **name**: Char required +- **parent**: Many2One -> `res.group` +- **rule_groups**: Many2Many -> `ir.rule.group-res.group` +- **users**: Many2Many -> `res.user-res.group` + +## `res.notification` _(Felder aus: res)_ + +- **action**: Many2One -> `ir.action` +- **action_value**: Char +- **description**: Char +- **icon**: Selection +- **label**: Char +- **model**: Char +- **records**: Char +- **unread**: Boolean +- **user**: Many2One -> `res.user` required + +## `res.user` _(Felder aus: company, res, stock)_ + +- **actions**: Many2Many -> `res.user-ir.action` +- **applications**: One2Many -> `res.user.application` +- **avatar_badge_url**: Function[Char] NICHT setzbar (Function ohne setter) +- **companies**: Many2Many -> `res.user-company.company` (aus Modul `company`) +- **company**: Many2One -> `company.company` (aus Modul `company`) +- **company_filter**: Selection (aus Modul `company`) +- **email**: Char +- **employee**: Many2One -> `company.employee` (aus Modul `company`) +- **employees**: Many2Many -> `res.user-company.employee` (aus Modul `company`) +- **groups**: Many2Many -> `res.user-res.group` +- **language**: Many2One -> `ir.lang` +- **language_direction**: Function[Char] NICHT setzbar (Function ohne setter) +- **login**: Char required +- **menu**: Many2One -> `ir.action` +- **name**: Char +- **notifications**: MultiSelection +- **password**: Function[Char] +- **password_hash**: Char +- **password_reset**: Char +- **password_reset_expire**: Timestamp +- **pyson_menu**: Function[Char] NICHT setzbar (Function ohne setter) +- **sessions**: Function[Integer] NICHT setzbar (Function ohne setter) +- **signature**: Text +- **status_bar**: Function[Char] NICHT setzbar (Function ohne setter) +- **warehouse**: Many2One -> `stock.location` (aus Modul `stock`) +- **warnings**: One2Many -> `res.user.warning` + +## `res.user-company.company` _(Felder aus: company)_ + +- **company**: Many2One -> `company.company` required (aus Modul `company`) +- **user**: Many2One -> `res.user` required (aus Modul `company`) + +## `res.user-company.employee` _(Felder aus: company)_ + +- **employee**: Many2One -> `company.employee` required (aus Modul `company`) +- **user**: Many2One -> `res.user` required (aus Modul `company`) + +## `res.user-ir.action` _(Felder aus: res)_ + +- **action**: Many2One -> `ir.action` required +- **user**: Many2One -> `res.user` required + +## `res.user-res.group` _(Felder aus: res)_ + +- **group**: Many2One -> `res.group` required +- **user**: Many2One -> `res.user` required + +## `res.user.application` _(Felder aus: res)_ + +- **application**: Selection required +- **key**: Char required +- **state**: Selection +- **user**: Many2One -> `res.user` + +## `res.user.device` _(Felder aus: res)_ + +- **cookie**: Char required +- **login**: Char required + +## `res.user.login.attempt` _(Felder aus: res)_ + +- **device_cookie**: Char +- **ip_address**: Char +- **ip_network**: Char +- **login**: Char + +## `res.user.warning` _(Felder aus: res)_ + +- **always**: Boolean +- **name**: Char required +- **user**: Many2One -> `res.user` required + +## `stock.configuration` _(Felder aus: stock, stock_lot_sled, stock_shipment_measurements)_ + +- **inventory_sequence**: MultiValue +- **measurement_volume_uom**: MultiValue (aus Modul `stock_shipment_measurements`) +- **measurement_weight_uom**: MultiValue (aus Modul `stock_shipment_measurements`) +- **shelf_life_delay**: MultiValue (aus Modul `stock_lot_sled`) +- **shipment_in_return_sequence**: MultiValue +- **shipment_in_sequence**: MultiValue +- **shipment_internal_sequence**: MultiValue +- **shipment_internal_transit**: MultiValue +- **shipment_out_return_sequence**: MultiValue +- **shipment_out_sequence**: MultiValue + +## `stock.configuration.measurement` _(Felder aus: stock_shipment_measurements)_ + +- **measurement_volume_uom**: Many2One -> `product.uom` required (aus Modul `stock_shipment_measurements`) +- **measurement_weight_uom**: Many2One -> `product.uom` required (aus Modul `stock_shipment_measurements`) + +## `stock.configuration.sequence` _(Felder aus: stock)_ + +- **inventory_sequence**: Many2One -> `ir.sequence` required +- **shipment_in_return_sequence**: Many2One -> `ir.sequence` required +- **shipment_in_sequence**: Many2One -> `ir.sequence` required +- **shipment_internal_sequence**: Many2One -> `ir.sequence` required +- **shipment_out_return_sequence**: Many2One -> `ir.sequence` required +- **shipment_out_sequence**: Many2One -> `ir.sequence` required + +## `stock.inventory` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **date**: Date required +- **empty_quantity**: Selection +- **lines**: One2Many -> `stock.inventory.line` +- **location**: Many2One -> `stock.location` required +- **number**: Char +- **state**: Selection + +## `stock.inventory.count.quantity` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock, stock_lot)_ + +- **line**: Many2One -> `stock.inventory.line` required +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **product**: Many2One -> `product.product` +- **quantity**: Float required +- **total_quantity**: Float +- **unit**: Many2One -> `product.uom` + +## `stock.inventory.count.search` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **search**: Reference -> `Search` required + +## `stock.inventory.line` _(Felder aus: stock, stock_lot)_ + +- **expected_quantity**: Float required +- **inventory**: Many2One -> `stock.inventory` required +- **inventory_date**: Function[Date] NICHT setzbar (Function ohne setter) +- **inventory_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **inventory_state**: Function[Selection] NICHT setzbar (Function ohne setter) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **moves**: One2Many -> `stock.move` +- **product**: Many2One -> `product.product` required +- **quantity**: Float +- **unit**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.location` _(Felder aus: production, stock)_ + +- **address**: Many2One -> `party.address` +- **allow_pickup**: Boolean +- **childs**: One2Many -> `stock.location` +- **code**: Char +- **cost_value**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **flat_childs**: Boolean +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) +- **input_location**: Many2One -> `stock.location` +- **left**: Integer required +- **lost_found_location**: Many2One -> `stock.location` +- **name**: Char required +- **output_location**: Many2One -> `stock.location` +- **parent**: Many2One -> `stock.location` +- **picking_location**: Many2One -> `stock.location` +- **production_location**: Many2One -> `stock.location` (aus Modul `production`) +- **production_output_location**: Many2One -> `stock.location` (aus Modul `production`) +- **production_picking_location**: Many2One -> `stock.location` (aus Modul `production`) +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) +- **quantity_uom**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **right**: Integer required +- **storage_location**: Many2One -> `stock.location` +- **type**: Selection +- **warehouse**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **waste_locations**: Many2Many -> `stock.location.waste` +- **waste_warehouses**: Many2Many -> `stock.location.waste` + +## `stock.location.lead_time` _(Felder aus: stock)_ + +- **lead_time**: TimeDelta +- **warehouse_from**: Many2One -> `stock.location` +- **warehouse_to**: Many2One -> `stock.location` + +## `stock.location.waste` _(Felder aus: stock)_ + +- **location**: Many2One -> `stock.location` required +- **warehouse**: Many2One -> `stock.location` required + +## `stock.lot` _(Felder aus: stock_lot)_ + +- **default_uom**: Function[Many2One] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) + +## `stock.lot.trace` _(Felder aus: production, stock_lot)_ + +- **company**: Many2One -> `company.company` (aus Modul `stock_lot`) +- **date**: Date (aus Modul `stock_lot`) +- **document**: Reference -> `Document` (aus Modul `stock_lot`) +- **downward_traces**: Function[Many2Many] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **from_location**: Many2One -> `stock.location` (aus Modul `stock_lot`) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **product**: Many2One -> `product.product` (aus Modul `stock_lot`) +- **production_input**: Many2One -> `production` (aus Modul `production`) +- **production_output**: Many2One -> `production` (aus Modul `production`) +- **quantity**: Float (aus Modul `stock_lot`) +- **to_location**: Many2One -> `stock.location` (aus Modul `stock_lot`) +- **unit**: Many2One -> `product.uom` (aus Modul `stock_lot`) +- **upward_traces**: Function[Many2Many] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) + +## `stock.lots_by_location.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_lot)_ + +- **forecast_date**: Date (aus Modul `stock_lot`) +- **stock_date_end**: Function[Date] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) + +## `stock.lots_by_locations` _(Felder aus: stock_lot)_ + +- **default_uom**: Function[Many2One] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **product**: Many2One -> `product.product` (aus Modul `stock_lot`) +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) + +## `stock.move` _(Felder aus: production, stock, stock_lot, stock_shipment_measurements)_ + +- **assignation_required**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **company**: Many2One -> `company.company` required +- **cost_price**: Numeric +- **cost_price_required**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **currency**: Many2One -> `currency.currency` +- **delay**: Function[TimeDelta] NICHT setzbar (Function ohne setter) +- **effective_date**: Date +- **from_location**: Many2One -> `stock.location` required +- **from_location_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **internal_quantity**: Float required +- **internal_volume**: Float (aus Modul `stock_shipment_measurements`) +- **internal_weight**: Float (aus Modul `stock_shipment_measurements`) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **origin**: Reference -> `Origin` +- **origin_planned_date**: Date +- **outcome_moves**: One2Many -> `stock.move` +- **planned_date**: Date +- **product**: Many2One -> `product.product` required +- **product_cost_price**: Numeric +- **product_uom_category**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **production**: Function[Many2One] NICHT setzbar (Function ohne setter) (aus Modul `production`) +- **production_cost_price_updated**: Boolean (aus Modul `production`) +- **production_input**: Many2One -> `production` (aus Modul `production`) +- **production_output**: Many2One -> `production` (aus Modul `production`) +- **quantity**: Float required +- **shipment**: Reference -> `Shipment` +- **state**: Selection +- **to_location**: Many2One -> `stock.location` required +- **to_location_name**: Function[Char] NICHT setzbar (Function ohne setter) +- **unit**: Many2One -> `product.uom` required +- **unit_price**: Numeric +- **unit_price_company**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **unit_price_required**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **unit_price_updated**: Boolean + +## `stock.move.add.lots.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_lot)_ + +- **duplicate_lot_number**: Integer (aus Modul `stock_lot`) +- **lots**: One2Many -> `stock.move.add.lots.start.lot` (aus Modul `stock_lot`) +- **product**: Many2One -> `product.product` (aus Modul `stock_lot`) +- **quantity**: Float (aus Modul `stock_lot`) +- **quantity_remaining**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) +- **unit**: Many2One -> `product.uom` (aus Modul `stock_lot`) + +## `stock.move.add.lots.start.lot` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_lot)_ + +- **parent**: Many2One -> `stock.move.add.lots.start` (aus Modul `stock_lot`) +- **quantity**: Float required (aus Modul `stock_lot`) +- **quantity_unit**: Function[Many2One] NICHT setzbar (Function ohne setter) (aus Modul `stock_lot`) + +## `stock.move.split.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_split)_ + +- **count**: Integer (aus Modul `stock_split`) +- **quantity**: Float required (aus Modul `stock_split`) +- **unit**: Many2One -> `product.uom` required (aus Modul `stock_split`) +- **uom_category**: Many2One -> `product.uom.category` (aus Modul `stock_split`) + +## `stock.package` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_shipment_measurements)_ + +- **additional_weight**: Float (aus Modul `stock_shipment_measurements`) +- **additional_weight_uom**: Many2One -> `product.uom` (aus Modul `stock_shipment_measurements`) +- **total_volume**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_shipment_measurements`) +- **total_weight**: Function[Float] NICHT setzbar (Function ohne setter) (aus Modul `stock_shipment_measurements`) + +## `stock.period` _(Felder aus: stock, stock_lot)_ + +- **caches**: One2Many -> `stock.period.cache` +- **company**: Many2One -> `company.company` required +- **date**: Date required +- **lot_caches**: One2Many -> `stock.period.cache.lot` (aus Modul `stock_lot`) +- **state**: Selection + +## `stock.period.cache` _(Felder aus: stock)_ + +- **internal_quantity**: Float +- **location**: Many2One -> `stock.location` required +- **period**: Many2One -> `stock.period` required +- **product**: Many2One -> `product.product` required + +## `stock.period.cache.lot` _(Felder aus: stock_lot)_ + +- **internal_quantity**: Float (aus Modul `stock_lot`) +- **location**: Many2One -> `stock.location` required (aus Modul `stock_lot`) +- **lot**: Many2One -> `stock.lot` (aus Modul `stock_lot`) +- **period**: Many2One -> `stock.period` required (aus Modul `stock_lot`) +- **product**: Many2One -> `product.product` required (aus Modul `stock_lot`) + +## `stock.product.location` _(Felder aus: stock_product_location)_ + +- **location**: Many2One -> `stock.location` required (aus Modul `stock_product_location`) +- **product**: Many2One -> `product.product` (aus Modul `stock_product_location`) +- **template**: Many2One -> `product.template` required (aus Modul `stock_product_location`) +- **warehouse**: Many2One -> `stock.location` required (aus Modul `stock_product_location`) + +## `stock.product_quantities_warehouse` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` +- **product**: Reference -> `Product` +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) + +## `stock.product_quantities_warehouse.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **stock_skip_warehouse**: Boolean +- **warehouse**: Many2One -> `stock.location` required + +## `stock.product_quantities_warehouse.move` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` +- **cumulative_quantity_delta**: Float +- **cumulative_quantity_end**: Function[Float] NICHT setzbar (Function ohne setter) +- **cumulative_quantity_start**: Function[Float] NICHT setzbar (Function ohne setter) +- **date**: Date +- **document**: Function[Reference] NICHT setzbar (Function ohne setter) +- **move**: Many2One -> `stock.move` +- **origin**: Reference -> `Origin` +- **product**: Reference -> `Product` +- **quantity**: Float + +## `stock.products_by_locations` _(Felder aus: stock)_ + +- **consumable**: Function[Boolean] NICHT setzbar (Function ohne setter) +- **cost_value**: Function[Numeric] NICHT setzbar (Function ohne setter) +- **default_uom**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **forecast_quantity**: Function[Float] NICHT setzbar (Function ohne setter) +- **product**: Many2One -> `product.product` +- **quantity**: Function[Float] NICHT setzbar (Function ohne setter) + +## `stock.products_by_locations.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **forecast_date**: Date +- **stock_date_end**: Function[Date] NICHT setzbar (Function ohne setter) + +## `stock.reporting.inventory.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **date**: Date required +- **product_type**: Selection required + +## `stock.reporting.inventory.daily` _(Felder aus: stock)_ + +- **from_date**: Date +- **to_date**: Date + +## `stock.reporting.inventory.move` _(Felder aus: stock)_ + +- **date**: Date +- **document**: Function[Reference] NICHT setzbar (Function ohne setter) +- **move**: Many2One -> `stock.move` +- **origin**: Reference -> `Origin` + +## `stock.reporting.inventory.turnover` _(Felder aus: stock)_ + +- **average_quantity**: Float +- **company**: Many2One -> `company.company` +- **output_quantity**: Float +- **product**: Many2One -> `product.product` +- **product_reference**: Reference -> `Product` +- **product_template**: Many2One -> `product.template` +- **turnover**: Float +- **unit**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.reporting.inventory.turnover.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **product_type**: Selection required + +## `stock.reporting.margin.category` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **time_series**: One2Many -> `stock.reporting.margin.category.time_series` + +## `stock.reporting.margin.category.tree` _(Felder aus: stock)_ + +- **children**: One2Many -> `stock.reporting.margin.category.tree` +- **cost**: Function NICHT setzbar (Function ohne setter) +- **currency**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **margin**: Function NICHT setzbar (Function ohne setter) +- **name**: Function[Char] NICHT setzbar (Function ohne setter) +- **parent**: Many2One -> `stock.reporting.margin.category.tree` +- **profit**: Function NICHT setzbar (Function ohne setter) +- **revenue**: Function NICHT setzbar (Function ohne setter) + +## `stock.reporting.margin.context` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **from_date**: Date +- **include_lost**: Boolean +- **period**: Selection required +- **to_date**: Date + +## `stock.reporting.margin.main` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **time_series**: Function[Many2Many] NICHT setzbar (Function ohne setter) + +## `stock.reporting.margin.product` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **time_series**: One2Many -> `stock.reporting.margin.product.time_series` + +## `stock.shipment.assign.partial` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock)_ + +- **moves**: Many2Many -> `stock.move` + +## `stock.shipment.in` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **contact_address**: Many2One -> `party.address` +- **incoming_moves**: Function[One2Many] +- **inventory_moves**: Function[One2Many] +- **moves**: One2Many -> `stock.move` +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **state**: Selection +- **supplier**: Many2One -> `party.party` required +- **supplier_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse**: Many2One -> `stock.location` required +- **warehouse_input**: Many2One -> `stock.location` required +- **warehouse_storage**: Many2One -> `stock.location` required + +## `stock.shipment.in.return` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **delivery_address**: Many2One -> `party.address` +- **from_location**: Many2One -> `stock.location` required +- **moves**: One2Many -> `stock.move` +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **state**: Selection +- **supplier**: Many2One -> `party.party` required +- **to_location**: Many2One -> `stock.location` required +- **warehouse**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.shipment.internal` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **effective_start_date**: Date +- **from_location**: Many2One -> `stock.location` required +- **incoming_moves**: Function[One2Many] +- **internal_transit_location**: Many2One -> `stock.location` +- **moves**: One2Many -> `stock.move` +- **outgoing_moves**: Function[One2Many] +- **planned_start_date**: Date +- **state**: Selection +- **to_location**: Many2One -> `stock.location` required +- **to_warehouse**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **transit_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **warehouse**: Function[Many2One] NICHT setzbar (Function ohne setter) + +## `stock.shipment.out` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **customer**: Many2One -> `party.party` required +- **customer_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **delivery_address**: Many2One -> `party.address` required +- **inventory_moves**: Function[One2Many] +- **moves**: One2Many -> `stock.move` +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **outgoing_moves**: Function[One2Many] +- **state**: Selection +- **warehouse**: Many2One -> `stock.location` required +- **warehouse_output**: Many2One -> `stock.location` required +- **warehouse_storage**: Many2One -> `stock.location` required + +## `stock.shipment.out.return` _(Felder aus: stock)_ + +- **company**: Many2One -> `company.company` required +- **contact_address**: Many2One -> `party.address` +- **customer**: Many2One -> `party.party` required +- **customer_location**: Function[Many2One] NICHT setzbar (Function ohne setter) +- **incoming_moves**: Function[One2Many] +- **inventory_moves**: Function[One2Many] +- **moves**: One2Many -> `stock.move` +- **origins**: Function[Char] NICHT setzbar (Function ohne setter) +- **state**: Selection +- **warehouse**: Many2One -> `stock.location` required +- **warehouse_input**: Many2One -> `stock.location` required +- **warehouse_storage**: Many2One -> `stock.location` required + +## `stock.shipment.split.start` _(Wizard/Transient - nicht persistent)_ _(Felder aus: stock_split)_ + +- **domain_moves**: Many2Many -> `stock.move` (aus Modul `stock_split`) +- **moves**: Many2Many -> `stock.move` (aus Modul `stock_split`) diff --git a/reports/company.md b/reports/updateChanges/company.md similarity index 100% rename from reports/company.md rename to reports/updateChanges/company.md diff --git a/reports/country.md b/reports/updateChanges/country.md similarity index 100% rename from reports/country.md rename to reports/updateChanges/country.md diff --git a/reports/currency.md b/reports/updateChanges/currency.md similarity index 100% rename from reports/currency.md rename to reports/updateChanges/currency.md diff --git a/reports/ir.md b/reports/updateChanges/ir.md similarity index 100% rename from reports/ir.md rename to reports/updateChanges/ir.md diff --git a/reports/party.md b/reports/updateChanges/party.md similarity index 100% rename from reports/party.md rename to reports/updateChanges/party.md diff --git a/reports/product.md b/reports/updateChanges/product.md similarity index 100% rename from reports/product.md rename to reports/updateChanges/product.md diff --git a/reports/product_measurements.md b/reports/updateChanges/product_measurements.md similarity index 100% rename from reports/product_measurements.md rename to reports/updateChanges/product_measurements.md diff --git a/reports/production.md b/reports/updateChanges/production.md similarity index 100% rename from reports/production.md rename to reports/updateChanges/production.md diff --git a/reports/production_split.md b/reports/updateChanges/production_split.md similarity index 100% rename from reports/production_split.md rename to reports/updateChanges/production_split.md diff --git a/reports/res.md b/reports/updateChanges/res.md similarity index 100% rename from reports/res.md rename to reports/updateChanges/res.md diff --git a/reports/stock_lot.md b/reports/updateChanges/stock_lot.md similarity index 100% rename from reports/stock_lot.md rename to reports/updateChanges/stock_lot.md diff --git a/reports/stock_lot_sled.md b/reports/updateChanges/stock_lot_sled.md similarity index 100% rename from reports/stock_lot_sled.md rename to reports/updateChanges/stock_lot_sled.md diff --git a/reports/stock_product_location.md b/reports/updateChanges/stock_product_location.md similarity index 100% rename from reports/stock_product_location.md rename to reports/updateChanges/stock_product_location.md diff --git a/reports/stock_split.md b/reports/updateChanges/stock_split.md similarity index 100% rename from reports/stock_split.md rename to reports/updateChanges/stock_split.md diff --git a/rst_to_dataset.py b/rst_to_dataset.py new file mode 100644 index 0000000..ae0a52e --- /dev/null +++ b/rst_to_dataset.py @@ -0,0 +1,317 @@ +#!/usr/bin/env python3 +""" +rst_to_dataset.py + +Extrahiert aus Tryton-Modul-Testdateien (tests/scenario_*.rst - das sind +ausführbare Doctests mit Proteus-Code in >>>-Zeilen) automatisch Record- +Definitionen im dataset.yaml-Format von create_dataset.py. + +Erkennt: + >>> Party = Model.get('party.party') # Modell-Zuordnung + >>> party = Party(name='Testfirma GmbH') # Instanziierung + Felder + >>> party.vat_number = '123' # weitere Feld-Zuweisung + >>> party.save() # Abschluss -> Record wird übernommen + +sowie Referenzen auf andere in derselben Datei bereits angelegte Records +(z. B. `address.party = party`) -> werden zu {"$ref": "..."}, und die +gängigsten nicht-JSON-tauglichen Werte: + Decimal('12.34') -> {"$decimal": "12.34"} + datetime.date(2024, 1, 1) -> {"$date": "2024-01-01"} + +Alles andere (Wizards, .click(...), Reports, One2Many .new()/.append(), +Aufrufe von Hilfsfunktionen wie create_company()) wird NICHT automatisch +aufgelöst, sondern als {"$manual": ""} markiert bzw. +komplett übersprungen und in der Zusammenfassung aufgelistet - das ist +bewusst so: lieber sichtbar unvollständig als still falsch. + +Nutzung: + python3 rst_to_dataset.py tests/scenario_party.rst tests/scenario_address.rst \\ + --output-dir extracted/ + + Erzeugt extracted/scenario_party.yaml, extracted/scenario_address.yaml. + Record-Keys werden mit dem Dateinamen präfixiert (party__party_1 statt + nur party_1), damit beim manuellen Zusammenführen mehrerer Module keine + Kollisionen entstehen. + +WICHTIG: Ungetestet gegen echte .rst-Dateien (hier ohne Netzwerkzugriff auf +das Tryton-Repo) - nur gegen eine selbstgebaute Beispieldatei verifiziert +(siehe Testlauf in der Antwort). Bitte an echten Dateien gegenprüfen, bevor +du dich auf die Ausgabe verlässt - der "manual"-Anteil wird bei komplexeren +Szenarien vermutlich größer sein als im Testfall. +""" + +import argparse +import ast +import re +import sys +from pathlib import Path + +try: + import yaml +except ImportError: + yaml = None + + +PROMPT_RE = re.compile(r'^\s*>>>\s?(.*)$') +CONTINUATION_RE = re.compile(r'^\s*\.\.\.\s?(.*)$') + + +def extract_doctest_source(text): + """Zieht alle >>>/...-Zeilen aus einer .rst-Datei und reiht sie zu einem + zusammenhängenden Python-Quelltext aneinander. Alles andere (Prosa, + erwartete Ausgabe) wird ignoriert.""" + lines = [] + for raw_line in text.splitlines(): + m = PROMPT_RE.match(raw_line) + if m: + lines.append(m.group(1)) + continue + m = CONTINUATION_RE.match(raw_line) + if m: + lines.append(m.group(1)) + continue + return "\n".join(lines) + + +def is_call_to(node, *dotted_names): + """True, wenn node ein Call ist, dessen func-Ausdruck (als unparse-Text) + zu einem der übergebenen Namen passt, z. B. 'Model.get' oder 'Decimal'.""" + if not isinstance(node, ast.Call): + return False + try: + text = ast.unparse(node.func) + except Exception: + return False + return text in dotted_names + + +def resolve_model_get(node): + """Liefert den Modellnamen aus einem Model.get('x.y')-Aufruf, sonst None.""" + if not is_call_to(node, "Model.get"): + return None + if len(node.args) != 1 or not isinstance(node.args[0], ast.Constant): + return None + if not isinstance(node.args[0].value, str): + return None + return node.args[0].value + + +class ScenarioParser: + def __init__(self): + self.model_vars = {} # Variable -> Modellname (aus Model.get(...)) + self.record_vars = {} # Variable -> Record-Dict (key/model/fields) + self.finalized = set() # Variablen, deren erster .save()-Aufruf schon verarbeitet wurde + self.output = [] # fertige Record-Dicts in Reihenfolge + self.manual_notes = [] # Zeilen, die nicht automatisch verstanden wurden + + def convert_value(self, node): + if isinstance(node, ast.Constant): + return node.value + + if isinstance(node, ast.Name): + if node.id in self.record_vars: + return {"$ref": self.record_vars[node.id]["key"]} + return self._manual(node) + + if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub): + inner = self.convert_value(node.operand) + if isinstance(inner, (int, float)): + return -inner + return self._manual(node) + + if isinstance(node, ast.Call): + if is_call_to(node, "Decimal") and node.args and isinstance(node.args[0], ast.Constant): + return {"$decimal": str(node.args[0].value)} + + if is_call_to(node, "datetime.date", "date") and len(node.args) >= 3: + try: + y, m, d = (a.value for a in node.args[:3]) + return {"$date": f"{int(y):04d}-{int(m):02d}-{int(d):02d}"} + except Exception: + pass + + return self._manual(node) + + if isinstance(node, (ast.List, ast.Tuple)): + return [self.convert_value(el) for el in node.elts] + + return self._manual(node) + + def _manual(self, node): + try: + text = ast.unparse(node) + except Exception: + text = "" + self.manual_notes.append(f"Zeile {getattr(node, 'lineno', '?')}: {text}") + return {"$manual": text} + + def make_key(self, var_name): + base = var_name + key = base + i = 2 + existing_keys = {r["key"] for r in self.output} | { + r["key"] for r in self.record_vars.values() + } + while key in existing_keys: + key = f"{base}_{i}" + i += 1 + return key + + def handle_assign(self, node): + if len(node.targets) != 1: + self._manual(node) + return + target = node.targets[0] + + # X = Model.get('some.model') + if isinstance(target, ast.Name): + model_name = resolve_model_get(node.value) + if model_name: + self.model_vars[target.id] = model_name + return + + # x = SomeModelVar(...) ODER x = Model.get('x.y')(...) + model_name = None + kwargs = {} + if isinstance(node.value, ast.Call): + func = node.value.func + if isinstance(func, ast.Name) and func.id in self.model_vars: + model_name = self.model_vars[func.id] + else: + model_name = resolve_model_get(func) + + if model_name: + for kw in node.value.keywords: + if kw.arg: + kwargs[kw.arg] = self.convert_value(kw.value) + + if model_name: + key = self.make_key(target.id) + self.record_vars[target.id] = { + "key": key, + "model": model_name, + "fields": kwargs, + } + return + + # x = , z. B. Ergebnis einer Helper-Funktion + # (create_company(), Party.find([...])[0], ...) - können wir + # nicht auflösen. + self.manual_notes.append( + f"Zeile {node.lineno}: '{target.id} = {ast.unparse(node.value)}' " + f"nicht automatisch aufgelöst (kein erkanntes Modell/Konstruktor)." + ) + return + + # x.feld = value + if isinstance(target, ast.Attribute) and isinstance(target.value, ast.Name): + var = target.value.id + if var in self.record_vars: + self.record_vars[var]["fields"][target.attr] = self.convert_value(node.value) + return + + self._manual(node) + + def handle_call_statement(self, node): + call = node.value + if not isinstance(call, ast.Call) or not isinstance(call.func, ast.Attribute): + return + if call.func.attr != "save": + return + if not isinstance(call.func.value, ast.Name): + return + + var = call.func.value.id + if var in self.record_vars and var not in self.finalized: + self.output.append(dict(self.record_vars[var])) + self.finalized.add(var) + + def parse(self, source): + try: + tree = ast.parse(source) + except SyntaxError as e: + raise ValueError(f"Konnte extrahierten Doctest-Code nicht parsen: {e}") from e + + for stmt in tree.body: + if isinstance(stmt, ast.Assign): + self.handle_assign(stmt) + elif isinstance(stmt, ast.Expr): + self.handle_call_statement(stmt) + # alles andere (if/for/import/...) wird bewusst ignoriert + + +def namespace_keys(records, prefix): + """Schreibt allen Record-Keys (und $ref-Verweisen darauf) ein Präfix + voran, damit beim manuellen Zusammenführen mehrerer Module-YAMLs keine + Kollisionen entstehen.""" + rename = {r["key"]: f"{prefix}__{r['key']}" for r in records} + + def rewrite(value): + if isinstance(value, dict): + if "$ref" in value and value["$ref"] in rename: + return {"$ref": rename[value["$ref"]]} + return {k: rewrite(v) for k, v in value.items()} + if isinstance(value, list): + return [rewrite(v) for v in value] + return value + + result = [] + for r in records: + result.append({ + "key": rename[r["key"]], + "model": r["model"], + "fields": {k: rewrite(v) for k, v in r["fields"].items()}, + }) + return result + + +def process_file(path, output_dir): + text = Path(path).read_text(encoding="utf-8") + source = extract_doctest_source(text) + + parser = ScenarioParser() + parser.parse(source) + + prefix = Path(path).stem + records = namespace_keys(parser.output, prefix) + + out_path = Path(output_dir) / f"{prefix}.yaml" + out_path.parent.mkdir(parents=True, exist_ok=True) + + doc = {"records": records} + if yaml is not None: + out_path.write_text( + yaml.dump(doc, allow_unicode=True, sort_keys=False, default_flow_style=False), + encoding="utf-8", + ) + else: + import json + out_path.write_text(json.dumps(doc, indent=2, ensure_ascii=False), encoding="utf-8") + + return out_path, len(records), parser.manual_notes + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("rst_files", nargs="+", help="Ein oder mehrere scenario_*.rst-Dateien") + parser.add_argument("--output-dir", default="extracted", help="Zielordner für die YAMLs") + args = parser.parse_args() + + for rst_file in args.rst_files: + try: + out_path, count, notes = process_file(rst_file, args.output_dir) + except ValueError as e: + print(f"{rst_file}: FEHLER - {e}", file=sys.stderr) + continue + + print(f"{rst_file} -> {out_path} ({count} Record(s) erkannt)") + if notes: + print(f" {len(notes)} Ausdruck/Ausdrücke nicht automatisch aufgelöst (siehe $manual im YAML):") + for note in notes[:10]: + print(f" - {note}") + if len(notes) > 10: + print(f" ... und {len(notes) - 10} weitere") + + +if __name__ == "__main__": + main() diff --git a/rsts_merge_dedup.py b/rsts_merge_dedup.py new file mode 100644 index 0000000..1362239 --- /dev/null +++ b/rsts_merge_dedup.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +""" +rsts_merge_dedup.py + +Liest alle von rst_to_dataset.py erzeugten *.yaml-Dateien aus einem +Verzeichnis ein, entfernt Records mit identischem model+fields (die Keys +unterscheiden sich zwar je Datei durch das Präfix, der Inhalt ist aber oft +gleich, z. B. dasselbe Basis-product.template in vielen Szenarien) und +schreibt eine einzige zusammengeführte, nach model sortierte Datei. + +$ref-Verweise auf entfernte Duplikate werden automatisch auf den jeweils +behaltenen Record umgeschrieben. + +ACHTUNG: Es wird bewusst GLOBAL dedupliziert, auch innerhalb derselben +Datei. Das kann bei Szenarien, die zwei absichtlich gleich aussehende +Records anlegen (z. B. scenario_party_replace.yaml: zwei Parteien namens +"Pam", um eine davon zu ersetzen), einen der beiden Records entfernen und +damit den Sinn des Szenarios verändern. Für den Zweck hier (grober +Testdatensatz) ist das laut Absprache in Ordnung - falls die Datei später +1:1 für szenario-treue Tests verwendet werden soll, nochmal prüfen. + +Nutzung: + python3 rsts_merge_dedup.py rsts/8e --output reports/8_testdata_merged.yaml +""" + +import argparse +import heapq +import json +import sys +from pathlib import Path + +try: + import yaml +except ImportError: + yaml = None + + +def load_records(path): + text = path.read_text(encoding="utf-8") + if yaml is not None: + data = yaml.safe_load(text) + else: + data = json.loads(text) + return data.get("records", []) + + +def rewrite_refs(value, rename): + if isinstance(value, dict): + if "$ref" in value: + return {"$ref": rename.get(value["$ref"], value["$ref"])} + return {k: rewrite_refs(v, rename) for k, v in value.items()} + if isinstance(value, list): + return [rewrite_refs(v, rename) for v in value] + return value + + +def merge_and_dedupe(input_dir): + all_records = [] + for path in sorted(Path(input_dir).glob("*.yaml")): + for record in load_records(path): + all_records.append((path.name, record)) + + # Signatur = model + fields (Key bewusst ignoriert, da der sich je + # Datei nur durchs Präfix unterscheidet). + canonical_key = {} # signatur -> key des ersten Fundes + rename = {} # jeder key -> key des ersten Fundes derselben Signatur + kept = [] + removed = 0 + + for source, record in all_records: + signature = (record["model"], json.dumps(record["fields"], sort_keys=True)) + if signature in canonical_key: + rename[record["key"]] = canonical_key[signature] + removed += 1 + continue + canonical_key[signature] = record["key"] + rename[record["key"]] = record["key"] + kept.append(record) + + for record in kept: + record["fields"] = rewrite_refs(record["fields"], rename) + + kept = topo_sort_by_model(kept) + + return kept, removed + + +def find_refs(value): + if isinstance(value, dict): + if "$ref" in value: + yield value["$ref"] + else: + for v in value.values(): + yield from find_refs(v) + elif isinstance(value, list): + for v in value: + yield from find_refs(v) + + +def topo_sort_by_model(records): + """Sortiert primär nach model, respektiert dabei aber zwingend die + $ref-Abhängigkeiten (ein Record muss nach allem stehen, worauf er per + $ref verweist). Kahn-Algorithmus: unter allen gerade freien Records + (alle Abhängigkeiten schon platziert) wird immer der mit dem + alphabetisch kleinsten model+key gewählt - das gruppiert gleiche + models so weit, wie es die Abhängigkeiten zulassen.""" + by_key = {r["key"]: r for r in records} + deps = {r["key"]: set() for r in records} + dependents = {r["key"]: set() for r in records} + + for r in records: + for ref in find_refs(r["fields"]): + if ref in by_key and ref != r["key"]: + deps[r["key"]].add(ref) + dependents[ref].add(r["key"]) + + indegree = {k: len(v) for k, v in deps.items()} + heap = [(by_key[k]["model"], k) for k, deg in indegree.items() if deg == 0] + heapq.heapify(heap) + + result = [] + while heap: + _, key = heapq.heappop(heap) + result.append(by_key[key]) + for dependent in dependents[key]: + indegree[dependent] -= 1 + if indegree[dependent] == 0: + heapq.heappush(heap, (by_key[dependent]["model"], dependent)) + + if len(result) != len(records): + stuck = set(by_key) - {r["key"] for r in result} + raise ValueError( + f"Zyklische oder unauflösbare $ref-Abhängigkeiten bei: {sorted(stuck)}" + ) + + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("input_dir", help="Verzeichnis mit den *.yaml-Dateien (z. B. rsts/8e)") + parser.add_argument("--output", required=True, help="Zieldatei für den zusammengeführten Datensatz") + args = parser.parse_args() + + kept, removed = merge_and_dedupe(args.input_dir) + + doc = {"records": kept} + out_path = Path(args.output) + if yaml is not None: + out_path.write_text( + yaml.dump(doc, allow_unicode=True, sort_keys=False, default_flow_style=False), + encoding="utf-8", + ) + else: + out_path.write_text(json.dumps(doc, indent=2, ensure_ascii=False), encoding="utf-8") + + print(f"{len(kept)} Records behalten, {removed} Duplikate entfernt -> {out_path}") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/run.sh b/run.sh index 3aa7657..1851813 100755 --- a/run.sh +++ b/run.sh @@ -4,7 +4,7 @@ set -e TRYTON_REPO="$HOME/tmp/tryton" WORKDIR="$HOME/code/tryton-db-migration" -EXTRACTOR="$WORKDIR/extract.py" +EXTRACTOR="$WORKDIR/extract_updates.py" START='5.0' @@ -47,7 +47,7 @@ echo echo "starte Auswertung" echo "======================================================" -python3 compare.py +python3 compare_updates.py echo echo "Fertig."