odoo-addon-base-write-diff 17.0.1.0.0.2__py3-none-any.whl

odoo/addons/base_write_diff/tests/test_base_write_diff.py

@@ -0,0 +1,423 @@
+# Copyright 2025 Camptocamp SA
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
+
+from logging import getLogger
+
+from odoo_test_helper import FakeModelLoader
+
+from odoo import api, fields, models
+from odoo.tests import TransactionCase
+from odoo.tools.misc import mute_logger
+
+from odoo.addons.base.tests.common import DISABLED_MAIL_CONTEXT
+
+
+class TestRecordDiffCommon(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        # Setup env
+        cls.env = cls.env["base"].with_context(**DISABLED_MAIL_CONTEXT).env
+
+        # ``_register_hook()`` is usually called at the end of the test process, but
+        # we need to be able to test it here
+        cls.env["base"]._register_hook()
+
+        # Load test model
+        cls.loader = FakeModelLoader(cls.env, cls.__module__)
+        cls.loader.backup_registry()
+
+        class BWDTestModel(models.Model):
+            _name = "bwd.test.model"
+            _description = "Base Write Diff - Test Model"
+            _test_logger = getLogger("bwd.test.model.log")
+
+            # To test a non-relational field
+            name = fields.Char()
+            # To test single-relational fields
+            m2o_id = fields.Many2one("bwd.test.model")
+            # To test multi-relational fields
+            o2m_ids = fields.One2many("bwd.test.model", inverse_name="m2o_id")
+            m2m_ids = fields.Many2many("bwd.test.model", "test_rel", "id_1", "id_2")
+            # To test computed fields
+            # ``perimeter``: computed, stored field that depends on stored fields
+            # ``area``: computed, non-stored field that depends on stored fields
+            # ``volume``: computed, non-stored field that depends on non-stored fields
+            length = fields.Integer()  # pylint: disable=W8105  (Pylint complains this?)
+            width = fields.Integer()
+            height = fields.Integer()
+            perimeter = fields.Integer(compute="_compute_perimeter", store=True)
+            area = fields.Integer(compute="_compute_area", store=False)
+            volume = fields.Integer(compute="_compute_volume", store=False)
+
+            @api.depends("length", "width")
+            def _compute_perimeter(self):
+                self._test_logger.warning("Computing perimeter")
+                for rec in self:
+                    rec.perimeter = 2 * (rec.length + rec.width)
+
+            @api.depends("length", "width")
+            def _compute_area(self):
+                self._test_logger.warning("Computing area")
+                for rec in self:
+                    rec.area = rec.length * rec.width
+
+            @api.depends("area", "height")
+            def _compute_volume(self):
+                self._test_logger.warning("Computing volume")
+                for rec in self:
+                    rec.volume = rec.area * rec.height
+
+        cls.loader.update_registry([BWDTestModel])
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.loader.restore_registry()
+        super().tearDownClass()
+
+    def _create_records(self, count=1):
+        records = self.env["bwd.test.model"].create([{} for _ in range(1, count + 1)])
+        for rec in records:
+            rec.name = f"Record {rec.id}"
+        return records
+
+
+class TestRecordDiff(TestRecordDiffCommon):
+    @mute_logger("bwd.test.model.log")
+    def test_00_get_write_diff_values_simple(self):
+        """Test ``_get_write_diff_values()`` on fields that are not multi-relational"""
+        record = self._create_records()
+        # Try to write the same value on non-relational field
+        # => ``_get_write_diff_values()`` returns an empty dict
+        vals = {"name": record.name}
+        self.assertEqual(record._get_write_diff_values(vals), {})
+        # Try to write another value on non-relational field
+        # => ``_get_write_diff_values()`` returns the same dict
+        vals = {"name": record.name + " something else"}
+        self.assertEqual(record._get_write_diff_values(vals), vals)
+        # Try to write the same value on M2O field
+        # => ``_get_write_diff_values()`` returns an empty dict
+        vals = {"m2o_id": record.m2o_id.id}
+        self.assertEqual(record._get_write_diff_values(vals), {})
+        # Try to write another value on M2O field
+        # => ``_get_write_diff_values()`` returns the same dict
+        vals = {"m2o_id": self._create_records().id}
+        self.assertEqual(record._get_write_diff_values(vals), vals)
+
+    @mute_logger("bwd.test.model.log")
+    def test_10_get_write_diff_values_x2many_command_create(self):
+        """Test ``_get_write_diff_values()`` on fields.Command.create()
+
+        ``_get_write_diff_values()`` always returns the original dict, even after the
+        corecords are actually created (because the values will create a new, different
+        corecord if used on ``write()`` again)
+        """
+        record = self._create_records()
+        vals = {
+            "o2m_ids": [fields.Command.create({"name": "O2M Co-record"})],
+            "m2m_ids": [fields.Command.create({"name": "M2M Co-record"})],
+        }
+        self.assertEqual(record._get_write_diff_values(vals), vals)
+        record.write(vals)  # Do the real update => the diff is not empty anyway
+        self.assertEqual(record._get_write_diff_values(vals), vals)
+
+    @mute_logger("bwd.test.model.log")
+    def test_11_get_write_diff_values_x2many_command_update(self):
+        """Test ``_get_write_diff_values()`` on fields.Command.update()
+
+        ``_get_write_diff_values()`` returns only the subset of IDs/values that should
+        be updated
+        """
+        record = self._create_records()
+        # Create and assign 2 corecords to each X2M field
+        record.o2m_ids = o2m_corecords = self._create_records(2)
+        record.m2m_ids = m2m_corecords = self._create_records(2)
+        # Set vals to update 1 corecord on each X2M field
+        vals = {
+            "o2m_ids": [
+                fields.Command.update(o2m_corecords[0].id, {"name": "O2M Corec"}),
+                fields.Command.update(
+                    o2m_corecords[1].id, {"name": o2m_corecords[1].name}
+                ),
+            ],
+            "m2m_ids": [
+                fields.Command.update(
+                    m2m_corecords[0].id, {"name": m2m_corecords[0].name}
+                ),
+                fields.Command.update(m2m_corecords[1].id, {"name": "M2M Corec"}),
+            ],
+        }
+        # The diff should include only the IDs we want to update, and the fields we are
+        # actually different on them
+        self.assertEqual(
+            record._get_write_diff_values(vals),
+            {
+                "o2m_ids": [
+                    fields.Command.update(o2m_corecords[0].id, {"name": "O2M Corec"})
+                ],
+                "m2m_ids": [
+                    fields.Command.update(m2m_corecords[1].id, {"name": "M2M Corec"})
+                ],
+            },
+        )
+        record.write(vals)  # Do the real update => the diff should be empty now
+        self.assertEqual(record._get_write_diff_values(vals), {})
+
+    @mute_logger("bwd.test.model.log")
+    def test_12_get_write_diff_values_x2many_command_delete(self):
+        """Test ``_get_write_diff_values()`` on fields.Command.delete()
+
+        ``_get_write_diff_values()`` returns only the subset of IDs that should be
+        deleted/unlinked
+        """
+        record = self._create_records()
+        # Create and assign 2 corecords to each X2M field
+        record.o2m_ids = o2m_corecords = self._create_records(2)
+        record.m2m_ids = m2m_corecords = self._create_records(2)
+        # Set vals to delete 1 corecord in each X2M field
+        vals = {
+            "o2m_ids": [fields.Command.delete(o2m_corecords[0].id)],
+            "m2m_ids": [fields.Command.delete(m2m_corecords[1].id)],
+        }
+        # The diff should include only the IDs we want to delete
+        self.assertEqual(
+            record._get_write_diff_values(vals),
+            # Odoo assigns command "delete" or "unlink" according to the field type
+            # and its definition (not important for our purposes here)
+            {
+                "o2m_ids": [fields.Command.delete(o2m_corecords[0].id)],
+                "m2m_ids": [fields.Command.unlink(m2m_corecords[1].id)],
+            },
+        )
+        record.write(vals)  # Do the real update => the diff should be empty now
+        self.assertEqual(record._get_write_diff_values(vals), {})
+
+    @mute_logger("bwd.test.model.log")
+    def test_13_get_write_diff_values_x2many_command_unlink(self):
+        """Test ``_get_write_diff_values()`` on fields.Command.unlink()
+
+        ``_get_write_diff_values()`` returns only the subset of IDs that should be
+        deleted/unlinked
+        """
+        record = self._create_records()
+        # Create and assign 2 corecords to each X2M field
+        record.o2m_ids = o2m_corecords = self._create_records(2)
+        record.m2m_ids = m2m_corecords = self._create_records(2)
+        # Set vals to unlink 1 corecord in each X2M field
+        vals = {
+            "o2m_ids": [fields.Command.unlink(o2m_corecords[0].id)],
+            "m2m_ids": [fields.Command.unlink(m2m_corecords[1].id)],
+        }
+        # The diff should include only the IDs we want to unlink
+        self.assertEqual(
+            record._get_write_diff_values(vals),
+            # Odoo assigns command "delete" or "unlink" according to the field type
+            # and its definition (not important for our purposes here)
+            {
+                "o2m_ids": [fields.Command.delete(o2m_corecords[0].id)],
+                "m2m_ids": [fields.Command.unlink(m2m_corecords[1].id)],
+            },
+        )
+        record.write(vals)  # Do the real update => the diff should be empty now
+        self.assertEqual(record._get_write_diff_values(vals), {})
+
+    @mute_logger("bwd.test.model.log")
+    def test_14_get_write_diff_values_x2many_command_link(self):
+        """Test ``_get_write_diff_values()`` on fields.Command.link()
+
+        ``_get_write_diff_values()`` returns only the subset of IDs that should be
+        linked
+        """
+        record = self._create_records()
+        # Create 2 corecords
+        o2m_corecords = self._create_records(2)
+        m2m_corecords = self._create_records(2)
+        # Assign 1 corecord to each X2M field
+        record.write(
+            {
+                "o2m_ids": [fields.Command.set(o2m_corecords[0].ids)],
+                "m2m_ids": [fields.Command.set(m2m_corecords[1].ids)],
+            }
+        )
+        # Set vals to link all corecords on each X2M field
+        vals = {
+            "o2m_ids": [fields.Command.link(i) for i in o2m_corecords.ids],
+            "m2m_ids": [fields.Command.link(i) for i in m2m_corecords.ids],
+        }
+        # The diff should include only the IDs we want to link that are not already
+        # linked
+        self.assertEqual(
+            record._get_write_diff_values(vals),
+            # Odoo will update the commands to include the {"id": corecord.id} in them
+            {
+                "o2m_ids": [
+                    (
+                        fields.Command.LINK,
+                        o2m_corecords[1].id,
+                        {"id": o2m_corecords[1].id},
+                    )
+                ],
+                "m2m_ids": [
+                    (
+                        fields.Command.LINK,
+                        m2m_corecords[0].id,
+                        {"id": m2m_corecords[0].id},
+                    )
+                ],
+            },
+        )
+        record.write(vals)  # Do the real update => the diff should be empty now
+        self.assertEqual(record._get_write_diff_values(vals), {})
+
+    @mute_logger("bwd.test.model.log")
+    def test_15_get_write_diff_values_x2many_command_clear(self):
+        """Test ``_get_write_diff_values()`` on fields.Command.clear()
+
+        ``_get_write_diff_values()`` returns only the subset of IDs that should be
+        deleted/unlinked
+        """
+        record = self._create_records()
+        # Create and assign 2 corecords to each X2M field
+        record.o2m_ids = o2m_corecords = self._create_records(2)
+        record.m2m_ids = m2m_corecords = self._create_records(2)
+        # Set vals to clear each X2M field
+        vals = {
+            "o2m_ids": [fields.Command.clear()],
+            "m2m_ids": [fields.Command.clear()],
+        }
+        self.assertEqual(
+            record._get_write_diff_values(vals),
+            # Odoo assigns command "delete" or "unlink" according to the field type
+            # and its definition (not important for our purposes here)
+            {
+                "o2m_ids": [fields.Command.delete(i) for i in o2m_corecords.ids],
+                "m2m_ids": [fields.Command.unlink(i) for i in m2m_corecords.ids],
+            },
+        )
+        record.write(vals)  # Do the real update => the diff should be empty now
+        self.assertEqual(record._get_write_diff_values(vals), {})
+
+    @mute_logger("bwd.test.model.log")
+    def test_16_get_write_diff_values_x2many_command_set(self):
+        """Test ``_get_write_diff_values()`` on fields.Command.set()
+
+        ``_get_write_diff_values()`` behavior depends on various cases
+        """
+        record = self._create_records()
+        # Create 3 corecords for each X2M field
+        o2m_corecords = self._create_records(3)
+        m2m_corecords = self._create_records(3)
+
+        # Case 1:
+        # - X2M fields contain no corecords
+        # - we want to assign them some corecords
+        # => ``_get_write_diff_values()`` should return a ``fields.Command.link()``
+        #    command for each corecord to add
+        self.assertEqual(
+            record._get_write_diff_values(
+                {
+                    "o2m_ids": [fields.Command.set(o2m_corecords.ids)],
+                    "m2m_ids": [fields.Command.set(m2m_corecords.ids)],
+                },
+            ),
+            # Odoo will update the commands to "link", and it will add the
+            # {"id": corecord.id} in them
+            {
+                "o2m_ids": [
+                    (fields.Command.LINK, i, {"id": i}) for i in o2m_corecords.ids
+                ],
+                "m2m_ids": [
+                    (fields.Command.LINK, i, {"id": i}) for i in m2m_corecords.ids
+                ],
+            },
+        )
+
+        # Case 2:
+        # - X2M fields contain some corecords
+        # - we want to replace them with different corecords
+        # => ``_get_write_diff_values()`` should return a
+        #    ``fields.Command.[delete|unlink]()`` command for each corecord to remove,
+        #    and a ``fields.Command.link()`` command for each corecord to add
+        record.o2m_ids = o2m_corecords[:1]
+        record.m2m_ids = m2m_corecords[:2]
+        self.assertEqual(
+            record._get_write_diff_values(
+                {
+                    "o2m_ids": [fields.Command.set(o2m_corecords[1:].ids)],
+                    "m2m_ids": [fields.Command.set(m2m_corecords[2:].ids)],
+                },
+            ),
+            # Odoo will update the commands to "unlink", "delete" and "link" (with the
+            # {"id": corecord.id} in the "link" ones)
+            {
+                "o2m_ids": [
+                    (fields.Command.DELETE, i, 0) for i in o2m_corecords[:1].ids
+                ]
+                + [(fields.Command.LINK, i, {"id": i}) for i in o2m_corecords[1:].ids],
+                "m2m_ids": [
+                    (fields.Command.UNLINK, i, 0) for i in m2m_corecords[:2].ids
+                ]
+                + [(fields.Command.LINK, i, {"id": i}) for i in m2m_corecords[2:].ids],
+            },
+        )
+
+        # Case 3:
+        # - X2M fields contain some corecords
+        # - we want to reassign the same corecords
+        # => ``_get_write_diff_values()`` should return nothing
+        record.o2m_ids = o2m_corecords
+        record.m2m_ids = m2m_corecords
+        self.assertEqual(
+            record._get_write_diff_values(
+                {
+                    "o2m_ids": [fields.Command.set(o2m_corecords.ids)],
+                    "m2m_ids": [fields.Command.set(m2m_corecords.ids)],
+                },
+            ),
+            {},
+        )
+
+        # Case 4:
+        # - X2M fields contain some corecords
+        # - we want to remove all corecords
+        # => ``_get_write_diff_values()`` should return a
+        #    ``fields.Command.[delete|unlink]()`` command for each linked corecord
+        self.assertEqual(
+            record._get_write_diff_values(
+                {
+                    "o2m_ids": [fields.Command.set([])],
+                    "m2m_ids": [fields.Command.set([])],
+                },
+            ),
+            # Odoo will update the commands to "unlink" and "delete"
+            {
+                "o2m_ids": [(fields.Command.DELETE, i, 0) for i in o2m_corecords.ids],
+                "m2m_ids": [(fields.Command.UNLINK, i, 0) for i in m2m_corecords.ids],
+            },
+        )
+
+    # pylint: disable=W0104
+    def test_20_write_diff_computed_fields(self):
+        """Checks cache behavior for computed fields when diff-writing their deps"""
+        # Prepare the record, its fields values and the cache
+        record = self._create_records()
+        vals = {"length": 5, "width": 3, "height": 2}
+        record.write(vals)
+        fnames = ("perimeter", "area", "volume")
+        for fname in fnames:
+            with mute_logger("bwd.test.model.log"):
+                record[fname]  # Dummy read: set fields in cache
+
+        # Use ``write`` w/ the same values: Odoo will need to recompute the computed
+        # fields values as soon as they're read
+        record.write(vals)
+        for fname in fnames:
+            with self.assertLogs("bwd.test.model.log", level="WARNING"):
+                record[fname]  # Dummy read: check the compute method is triggered
+
+        # Use ``write_diff`` w/ the same values: Odoo won't need to recompute the
+        # computed fields values
+        record.write_diff(vals)
+        for fname in fnames:
+            with self.assertNoLogs("bwd.test.model.log", level="WARNING"):
+                record[fname]  # Dummy read: check the compute method is not triggered

odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.1
+Name: odoo-addon-base_write_diff
+Version: 17.0.1.0.0.2
+Requires-Python: >=3.10
+Requires-Dist: odoo>=17.0a,<17.1dev
+Summary: Prevents updates on fields whose values won't change anyway
+Home-page: https://github.com/OCA/server-tools
+License: AGPL-3
+Author: Camptocamp, Odoo Community Association (OCA)
+Author-email: support@odoo-community.org
+Classifier: Programming Language :: Python
+Classifier: Framework :: Odoo
+Classifier: Framework :: Odoo :: 17.0
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Description-Content-Type: text/x-rst
+
+.. image:: https://odoo-community.org/readme-banner-image
+   :target: https://odoo-community.org/get-involved?utm_source=readme
+   :alt: Odoo Community Association
+
+=================
+Base - Write Diff
+=================
+
+.. 
+   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+   !! This file is generated by oca-gen-addon-readme !!
+   !! changes will be overwritten.                   !!
+   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+   !! source digest: sha256:71745a37619c24019b67f8558eb6c7be1b974ad0031b6ce40892e7eec305bcb3
+   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
+    :target: https://odoo-community.org/page/development-status
+    :alt: Beta
+.. |badge2| image:: https://img.shields.io/badge/license-AGPL--3-blue.png
+    :target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
+    :alt: License: AGPL-3
+.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fserver--tools-lightgray.png?logo=github
+    :target: https://github.com/OCA/server-tools/tree/17.0/base_write_diff
+    :alt: OCA/server-tools
+.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
+    :target: https://translation.odoo-community.org/projects/server-tools-17-0/server-tools-17-0-base_write_diff
+    :alt: Translate me on Weblate
+.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
+    :target: https://runboat.odoo-community.org/builds?repo=OCA/server-tools&target_branch=17.0
+    :alt: Try me on Runboat
+
+|badge1| |badge2| |badge3| |badge4| |badge5|
+
+This module allows filtering values to update on records according to
+whether they are actually different from the records' current values.
+
+**Table of contents**
+
+.. contents::
+   :local:
+
+Usage
+=====
+
+**Summary**
+
+This module allows you to update records by filtering out fields whose
+values are going to be left unchanged by ``BaseModel.write()``; for
+example, let's assume you have:
+
+.. code:: python
+
+   >>> self
+   sale.order.line(1,)
+   >>> self.price_unit
+   10.00
+
+If you use ``self.write({"price_unit": 10.00})`` or
+``self.price_unit = 10.00``, Odoo may end up executing unnecessary
+operations, like triggering the update on the field, recompute computed
+fields that depend on ``price_unit``, and so on, even if the value is
+actually unchanged.
+
+By using this module, you can prevent all of that.
+
+You can use this module in 3 different ways. All of them require you to
+add this module as a dependency of your module.
+
+**1 - Context key ``"write_use_diff_values"``**
+
+By adding ``write_use_diff_values=True`` to the context when updating a
+field value, the ``BaseModel.write()`` patch will take care of filtering
+out the fields' values that are the same as the record's current ones.
+
+⚠️ Beware: the context key is propagated down to other ``write()`` calls
+
+Example:
+
+.. code:: python
+
+   from odoo import models
+
+
+   class ProductTemplate(models.Model):
+       _inherit = "product.template"
+
+       def write(self, vals):
+           # Update only fields that are actually different
+           self = self.with_context(write_use_diff_values=True)
+           return super().write(vals)
+
+
+   class ProductProduct(models.Model):
+       _inherit = "product.product"
+
+       def update_code_if_necessary(self, code: str):
+           # Update ``default_code`` only if different from the current value
+           self.with_context(write_use_diff_values=True).default_code = code
+
+**2 - Method ``BaseModel.write_diff()``**
+
+It is the same as calling ``write()``, but it automatically enables the
+``"write_use_diff_values"`` context flag: ``self.write_diff(vals)`` is a
+shortcut for
+``self.with_context(write_use_diff_values=True).write(vals)``
+
+⚠️ Beware: the context key is propagated down to other ``write()`` calls
+
+**3 - Method ``BaseModel._get_write_diff_values(vals)``**
+
+This method accepts a write-like ``dict`` as param, and returns a new
+``dict`` made of the fields who will actually update the record's
+values. This allows for a more flexible and customizable behavior than
+the context key usage, because:
+
+- you'll be able to filter out specific fields, instead of filtering out
+  all the fields whose values won't be changed after the update;
+- you'll be able to execute the filtering on specific models, instead of
+  executing it on all the models involved in the stack of ``write()``
+  calls from the first usage of the context key down to the base method
+  ``BaseModel.write()``.
+
+Example:
+
+.. code:: python
+
+   from collections import defaultdict
+
+   from odoo import api, models
+   from odoo.tools.misc import frozendict
+
+
+   class ProductProduct(models.Model):
+       _inherit = "product.product"
+
+       def write(self, vals):
+           # OVERRIDE: ``odoo.addons.product.models.product_product.Product.write()``
+           # override will clear the whole registry cache if either 'active' or
+           # 'product_template_attribute_value_ids' are found in the ``vals`` dictionary:
+           # remove them unless it's necessary to update them
+           fnames = {"active", "product_template_attribute_value_ids"}
+           if vals_to_check := {f: vals.pop(f) for f in fnames.intersection(vals)}:
+               groups = defaultdict(lambda: self.browse())
+               for prod in self:
+                   groups[frozendict(prod._get_write_diff_values(vals_to_check))] += prod
+               for diff_vals, prods in groups.items():
+                   if res_vals := (vals | dict(diff_vals)):
+                       super(ProductProduct, prods).write(res_vals)
+               return True
+           return super().write(vals)
+
+Bug Tracker
+===========
+
+Bugs are tracked on `GitHub Issues <https://github.com/OCA/server-tools/issues>`_.
+In case of trouble, please check there if your issue has already been reported.
+If you spotted it first, help us to smash it by providing a detailed and welcomed
+`feedback <https://github.com/OCA/server-tools/issues/new?body=module:%20base_write_diff%0Aversion:%2017.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
+
+Do not contact contributors directly about support or help with technical issues.
+
+Credits
+=======
+
+Authors
+-------
+
+* Camptocamp
+
+Contributors
+------------
+
+- Silvio Gregorini <silvio.gregorini@camptocamp.com>
+
+Maintainers
+-----------
+
+This module is maintained by the OCA.
+
+.. image:: https://odoo-community.org/logo.png
+   :alt: Odoo Community Association
+   :target: https://odoo-community.org
+
+OCA, or the Odoo Community Association, is a nonprofit organization whose
+mission is to support the collaborative development of Odoo features and
+promote its widespread use.
+
+This module is part of the `OCA/server-tools <https://github.com/OCA/server-tools/tree/17.0/base_write_diff>`_ project on GitHub.
+
+You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.

odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+odoo/addons/base_write_diff/README.rst,sha256=sZW-2soYGCfprm9XKjIgeeWjI2-9O6uOLgVcGZiZokk,6949
+odoo/addons/base_write_diff/__init__.py,sha256=X9EJGOE2GtZbS0G82PtSXmWSZ_R8jEM0rlJTDliQjp4,21
+odoo/addons/base_write_diff/__manifest__.py,sha256=wlJDjQpcjcz5Rbue3P_BXHS8s39-H-VLgkrSWxy4mYs,464
+odoo/addons/base_write_diff/i18n/base_write_diff.pot,sha256=G8ybp7izelJrFwRs4Dq3QeOjXqNSQD0WYhZeX8e86OI,463
+odoo/addons/base_write_diff/models/__init__.py,sha256=9pIQnc7H3xgVNpi7n3I18hg04S4IkX5mnAfl9cv7RBE,19
+odoo/addons/base_write_diff/models/base.py,sha256=m_BvhzFy-Z1hFMe4mtI0g5za-WVXhRiy_CBRmG-DIVY,6022
+odoo/addons/base_write_diff/readme/CONTRIBUTORS.md,sha256=I2EZz-IBsF_bZyhR1U8QoNZmB-m5qd7CGXRRRT0tkQE,57
+odoo/addons/base_write_diff/readme/DESCRIPTION.md,sha256=KGpIKiOVAfAVofJx1WzWT69_Bge7AifVh4LvMG5n1GI,140
+odoo/addons/base_write_diff/readme/USAGE.md,sha256=nRas9M95YRiVXh6FVUvTJ60YMBB6Fh2jhwBqvhM-2q8,3742
+odoo/addons/base_write_diff/static/description/icon.png,sha256=CgnOEZCwoe6f1vlLwkqFVfc2q_uwBMU0UnXN8j6X5ag,10254
+odoo/addons/base_write_diff/static/description/index.html,sha256=BPyYUioBiOJvIMe358jde59Xj4p-9jwJrQrrRoT3Eho,23403
+odoo/addons/base_write_diff/tests/__init__.py,sha256=54LbOvo7gqDhCdt6fz1qGm7h946smek_vCcKGC1s-UI,35
+odoo/addons/base_write_diff/tests/test_base_write_diff.py,sha256=n94okgQBw0-HGR-F8jWD0hKVZTN69605U-lhCucI7iY,18176
+odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/METADATA,sha256=WfkSpbaPsvQqbqemPY5zi5mAVobMxr4OyYOpXkJlgJ4,7537
+odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/WHEEL,sha256=ZhOvUsYhy81Dx67gN3TV0RchQWBIIzutDZaJODDg2Vo,81
+odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/top_level.txt,sha256=QE6RBQ0QX5f4eFuUcGgU5Kbq1A_qJcDs-e_vpr6pmfU,4
+odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/RECORD,,

odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: Whool 1.3
+Root-Is-Purelib: true
+Tag: py3-none-any
+

odoo_addon_base_write_diff-17.0.1.0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+odoo