PyOdoo 0.5.9__tar.gz → 0.6.0__tar.gz

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyOdoo
-Version: 0.5.9
+Version: 0.6.0
 Summary: API for Odoo
 Home-page: http://www.muflone.com/pyodoo/
 Author: Fabio Castelli
@@ -44,6 +44,8 @@ its XML RPC API.
 # System Requirements
 
 * Python 3.x
+* xlrd 2.0.x (https://pypi.org/project/xlrd/)
+* requests 2.31.x (https://pypi.org/project/requests/)
 
 # Usage
 

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/PyOdoo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyOdoo
-Version: 0.5.9
+Version: 0.6.0
 Summary: API for Odoo
 Home-page: http://www.muflone.com/pyodoo/
 Author: Fabio Castelli
@@ -44,6 +44,8 @@ its XML RPC API.
 # System Requirements
 
 * Python 3.x
+* xlrd 2.0.x (https://pypi.org/project/xlrd/)
+* requests 2.31.x (https://pypi.org/project/requests/)
 
 # Usage
 

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/PyOdoo.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ setup.cfg
 PyOdoo.egg-info/PKG-INFO
 PyOdoo.egg-info/SOURCES.txt
 PyOdoo.egg-info/dependency_links.txt
+PyOdoo.egg-info/requires.txt
 PyOdoo.egg-info/top_level.txt
 pyodoo/__init__.py
 pyodoo/active_status_choice.py
@@ -17,8 +18,11 @@ pyodoo/samples/__init__.py
 pyodoo/samples/awaitable.py
 pyodoo/samples/contacts.py
 pyodoo/samples/contacts_async.py
+pyodoo/samples/sql_excel_query.py
 pyodoo/v12/__init__.py
 pyodoo/v12/api.py
 pyodoo/v12/model.py
+pyodoo/v12/sql_excel_query.py
 tests/test_compare_types.py
-tests/test_contacts.py
+tests/test_contacts.py
+tests/test_sql_excel_query.py

PyOdoo-0.6.0/PyOdoo.egg-info/requires.txt

@@ -0,0 +1 @@
+xlrd==2.0.1

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/README.md

@@ -24,6 +24,8 @@ its XML RPC API.
 # System Requirements
 
 * Python 3.x
+* xlrd 2.0.x (https://pypi.org/project/xlrd/)
+* requests 2.31.x (https://pypi.org/project/requests/)
 
 # Usage
 

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/pyodoo/constants.py

@@ -19,7 +19,7 @@
 ##
 
 APP_NAME = 'PyOdoo'
-APP_VERSION = '0.5.9'
+APP_VERSION = '0.6.0'
 APP_DESCRIPTION = 'API for Odoo'
 APP_DOMAIN = 'pyodoo'
 APP_ID = f'{APP_DOMAIN}.muflone.com'

PyOdoo-0.6.0/pyodoo/samples/sql_excel_query.py

@@ -0,0 +1,81 @@
+##
+#     Project: PyOdoo
+# Description: API for Odoo
+#      Author: Fabio Castelli (Muflone) <muflone@muflone.com>
+#   Copyright: 2021-2023 Fabio Castelli
+#     License: GPL-3+
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+##
+
+import os
+
+from pyodoo.constants import APP_NAME, APP_VERSION
+from pyodoo.v12 import SqlExcelQuery
+
+
+# Check SQL Excel Query availability
+print(SqlExcelQuery.is_available(endpoint=os.environ['ODOO_ENDPOINT'],
+                                 database=os.environ['ODOO_DATABASE'],
+                                 username=os.environ['ODOO_USERNAME'],
+                                 password=os.environ['ODOO_PASSWORD'],
+                                 language=None))
+# Instance SQL Excel Query object
+query = SqlExcelQuery(name='test query 1',
+                      category=f'{APP_NAME} {APP_VERSION}',
+                      endpoint=os.environ['ODOO_ENDPOINT'],
+                      database=os.environ['ODOO_DATABASE'],
+                      username=os.environ['ODOO_USERNAME'],
+                      password=os.environ['ODOO_PASSWORD'],
+                      language=None)
+# Change default language
+query.language = 'en_GB'
+
+# Get Query ID
+print(query.id)
+
+# Set Query SQL text
+print(query.set_sql(text='SELECT\n  *\nFROM res_partner\nLIMIT 100'))
+
+# Set and get Query state
+query.set_draft()
+print(query.get_state())
+query.validate()
+print(query.get_state())
+
+# Set Query active status
+print(query.set_active(active=False))
+print(query.set_active(active=True))
+
+# Execute the SQL query
+query.execute()
+
+# Get Excel file
+data = query.get_file()
+
+# Process the Excel file and extract its data
+data = query.get_data()
+print(data)
+
+# Remove Excel file from SQL Excel Query
+query.clear()
+
+# Add query tags
+query.add_tag(tag_id=4)
+
+# Get the query tags
+data = query.get_tags()
+print(data)
+
+# Delete SQL Excel Query object
+print(query.delete())

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/pyodoo/v12/__init__.py

@@ -20,3 +20,4 @@
 
 from .api import Api                                               # noqa: F401
 from .model import Model                                           # noqa: F401
+from .sql_excel_query import SqlExcelQuery                         # noqa: F401

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/pyodoo/v12/model.py

@@ -92,20 +92,26 @@ class Model(object):
 
     def get_model(self,
                   model_name: str,
-                  authenticate: bool = False) -> 'Model':
+                  authenticate: bool = False,
+                  use_existing_uid: bool = False) -> 'Model':
         """
         Get a Model object for another model name
         :param model_name: Model name
         :param authenticate: Automatically authenticate user
+        :param use_existing_uid: Use the existing UID if not authenticated
         :return: Model object
         """
-        return Model(model_name=model_name,
-                     endpoint=self.api.endpoint,
-                     database=self.api.database,
-                     username=self.api.username,
-                     password=self.api.password,
-                     language=self.api.language,
-                     authenticate=authenticate)
+        model = Model(model_name=model_name,
+                      endpoint=self.api.endpoint,
+                      database=self.api.database,
+                      username=self.api.username,
+                      password=self.api.password,
+                      language=self.api.language,
+                      authenticate=authenticate)
+        if not authenticate and use_existing_uid:
+            # Use the existing UID
+            model.api.uid = self.api.uid
+        return model
 
     def get_model_data_reference(self,
                                  module_name: str,

PyOdoo-0.6.0/pyodoo/v12/sql_excel_query.py

@@ -0,0 +1,310 @@
+##
+#     Project: PyOdoo
+# Description: API for Odoo
+#      Author: Fabio Castelli (Muflone) <muflone@muflone.com>
+#   Copyright: 2021-2023 Fabio Castelli
+#     License: GPL-3+
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+##
+
+import base64
+import io
+from typing import Any, Optional
+
+import pyodoo
+from pyodoo.v12.model import Model
+
+import xlrd
+
+
+class SqlExcelQuery(object):
+    """
+    SQL Excel query to extract data from tables
+    """
+    def __init__(self,
+                 name: str,
+                 category: str,
+                 endpoint: str,
+                 database: str,
+                 username: str,
+                 password: str,
+                 language: str):
+        # Model object
+        self._query_name = name
+        self.model = Model(model_name='sql.excel.pdf',
+                           endpoint=endpoint,
+                           database=database,
+                           username=username,
+                           password=password,
+                           language=language,
+                           authenticate=True)
+        # Get or create the category ID
+        model_category = self.model.get_model(model_name='sql.category',
+                                              authenticate=False,
+                                              use_existing_uid=True)
+        results = model_category.search(
+            filters=[pyodoo.Filter(field='name',
+                                   compare_type=pyodoo.CompareType.EQUAL,
+                                   value=category)],
+            limit=1)
+        if results:
+            category_id = results[0]
+        else:
+            category_id = model_category.create(values={'name': category})
+        # Get or create the query object
+        results = self.model.search(
+            filters=[pyodoo.Filter(field='name',
+                                   compare_type=pyodoo.CompareType.EQUAL,
+                                   value=self.name)],
+            is_active=pyodoo.ActiveStatusChoice.BOTH,
+            limit=1)
+        if results:
+            self._query_id = results[0]
+        else:
+            # Query object doesn't exist, create it right now
+            self._query_id = self.model.create(
+                values={'name': self.name,
+                        'category_id': category_id,
+                        'sql_query': ''})
+
+    @staticmethod
+    def is_available(endpoint: str,
+                     database: str,
+                     username: str,
+                     password: str,
+                     language: str) -> bool:
+        """
+        Check if the sql.excel.pdf model exists
+
+        :param endpoint: Odoo instance endpoint
+        :param database: Odoo database
+        :param username: Odoo username
+        :param password: User password
+        :param language: Language for localizations
+
+        :return: True if the model sql.excel.pdf exists
+        """
+        model = Model(model_name='ir.model',
+                      endpoint=endpoint,
+                      database=database,
+                      username=username,
+                      password=password,
+                      language=language,
+                      authenticate=True)
+        results = model.search(
+            filters=[pyodoo.Filter(field='model',
+                                   compare_type=pyodoo.CompareType.EQUAL,
+                                   value='sql.excel.pdf')],
+            limit=1)
+        return bool(results)
+
+    @property
+    def name(self) -> str:
+        """
+        Get the current query name
+
+        :return: Query name
+        """
+        return self._query_name
+
+    @property
+    def language(self) -> str:
+        """
+        Get the current default language
+
+        :return: Language code
+        """
+        return self.model.language
+
+    @language.setter
+    def language(self,
+                 language: str):
+        """
+        Set the current default language
+
+        :param language: Language code to set
+        """
+        self.model.language = language
+
+    @property
+    def id(self) -> int:
+        """
+        Get the query object ID
+        :return: query object ID
+        """
+        return self._query_id
+
+    def get_sql(self) -> Optional[str]:
+        """
+        Get the query SQL text
+
+        :return: SQL text for the query
+        """
+        results = self.model.get(entity_id=self._query_id,
+                                 fields=('id',
+                                         'sql_query'))
+        return results['sql_query'] if results else None
+
+    def set_sql(self, text: str) -> bool:
+        """
+        Set the query SQL text
+
+        :param text: SQL text for query
+        :return: True if the query was updated
+        """
+        return self.model.update(entity_id=self._query_id,
+                                 values={'sql_query': text})
+
+    def set_draft(self) -> None:
+        """
+        Set the query object as draft
+        """
+        self.model.execute(method_name='action_reset_draft',
+                           args=[self._query_id],
+                           kwargs={},
+                           ignore_none_errors=True)
+
+    def validate(self) -> None:
+        """
+        Validate the query object
+        """
+        self.model.execute(method_name='action_validate',
+                           args=[self._query_id],
+                           kwargs={},
+                           ignore_none_errors=False)
+
+    def get_state(self) -> Optional[str]:
+        """
+        Get the query object state
+
+        :return: the query object state
+        """
+        results = self.model.get(entity_id=self._query_id,
+                                 fields=('state', ))
+        return results['state'] if results else None
+
+    def get_active(self) -> Optional[str]:
+        """
+        Get the query object active state
+
+        :return: the query object active state
+        """
+        results = self.model.get(entity_id=self._query_id,
+                                 fields=('active', ))
+        return results['active'] if results else None
+
+    def set_active(self, active: bool) -> bool:
+        """
+        Set the query object as active/inactive
+
+        :param active: active status
+        :return: True if the query was updated
+        """
+        return self.model.update(entity_id=self._query_id,
+                                 values={'active': active})
+
+    def execute(self) -> None:
+        """
+        Execute the query to create the Excel file in the `file` field
+
+        :return: None
+        """
+        self.model.execute(method_name='print_xls_report',
+                           args=[self._query_id],
+                           kwargs={},
+                           ignore_none_errors=True)
+        return None
+
+    def clear(self) -> None:
+        """
+        Clear the produced file
+        """
+        self.model.update(entity_id=self._query_id,
+                          values={'file': False})
+
+    def delete(self) -> bool:
+        """
+        Delete the query object
+
+        :return: True if the query was removed
+        """
+        return self.model.delete(entity_id=self._query_id)
+
+    def get_file(self) -> Optional[str]:
+        """
+        Get the latest produced Excel file
+
+        :return: Excel binary file content
+        """
+        results = self.model.get(entity_id=self._query_id,
+                                 fields=('file', ))
+        if results and results['file']:
+            # Decode the base64 content
+            results = base64.b64decode(s=results['file'])
+        else:
+            results = None
+        return results
+
+    def get_data(self) -> Optional[list[dict[str, Any]]]:
+        """
+        Get the latest produced Excel file and extract its tabular data
+
+        :return: list of dictionaries with data
+        """
+        with io.BytesIO() as file:
+            file.write(self.get_file())
+            with xlrd.open_workbook(file_contents=file.getvalue()) as workbook:
+                worksheet = workbook.sheet_by_index(0)
+                rows = worksheet.get_rows()
+                # Skip the first three rows
+                next(rows)
+                next(rows)
+                next(rows)
+                # Get the column headers
+                headers = [item.value
+                           for item in next(rows)]
+                # Get the data
+                results = []
+                for row in rows:
+                    results.append(dict(zip(headers,
+                                            [item.value for item in row])))
+        return results
+
+    def add_tag(self, tag_id: int) -> bool:
+        """
+        Add an existing tag to the query
+
+        :param tag_id: Tag ID to add
+        :return: True if the tag was added
+        """
+        return self.model.many_to_many_add(entity_id=self._query_id,
+                                           field='tag_ids',
+                                           related_id=tag_id)
+
+    def get_tags(self) -> Optional[list[dict[str, Any]]]:
+        """
+        Get the query tags
+
+        :return: list with the tags
+        """
+        if results := self.model.get(entity_id=self._query_id,
+                                     fields=('id',
+                                             'tag_ids')):
+            model = self.model.get_model(model_name='sql.tags',
+                                         authenticate=False,
+                                         use_existing_uid=True)
+            results = model.get_many(entity_ids=results['tag_ids'],
+                                     fields=('id',
+                                             'name'))
+        return results or None

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/setup.cfg

@@ -25,6 +25,8 @@ packages =
 	pyodoo
 	pyodoo.v12
 include_package_data = False
+install_requires = 
+	xlrd==2.0.1
 
 [options.package_data]
 pyodoo = samples/*

{PyOdoo-0.5.9 → PyOdoo-0.6.0}/tests/test_contacts.py

@@ -784,14 +784,35 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIn('string', field_name)
         self.assertIn('type', field_name)
 
-    def test_41_get_model(self) -> None:
+    def test_41_get_model_authenticate(self) -> None:
         """
         Get a new Model object
         """
         model_name = 'res.users'
-        results = self.model.get_model(model_name=model_name,
-                                       authenticate=False)
+        model = self.model.get_model(model_name=model_name,
+                                     authenticate=True,
+                                     use_existing_uid=False)
+        results = model.count(filters=[])
         # Check if we have results
+        self.assertIsNotNone(model)
+        self.assertIsInstance(model, Model)
+        self.assertEqual(model.model_name, model_name)
         self.assertIsNotNone(results)
-        self.assertIsInstance(results, Model)
-        self.assertEqual(results.model_name, model_name)
+        self.assertGreater(results, 0)
+
+    def test_42_get_model_no_authenticate(self) -> None:
+        """
+        Get a new Model object using the existing UID
+        """
+        self.model.authenticate()
+        model_name = 'res.users'
+        model = self.model.get_model(model_name=model_name,
+                                     authenticate=False,
+                                     use_existing_uid=True)
+        results = model.count(filters=[])
+        # Check if we have results
+        self.assertIsNotNone(model)
+        self.assertIsInstance(model, Model)
+        self.assertEqual(model.model_name, model_name)
+        self.assertIsNotNone(results)
+        self.assertGreater(results, 0)

PyOdoo-0.6.0/tests/test_sql_excel_query.py

@@ -0,0 +1,233 @@
+##
+#     Project: PyOdoo
+# Description: API for Odoo
+#      Author: Fabio Castelli (Muflone) <muflone@muflone.com>
+#   Copyright: 2021-2023 Fabio Castelli
+#     License: GPL-3+
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+##
+
+import unittest
+import uuid
+
+from pyodoo.constants import APP_NAME, APP_VERSION
+from pyodoo.v12 import SqlExcelQuery
+
+import utility
+
+
+class TestCaseSqlExcelQuery(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        """
+        Query object preparation
+        """
+        info = utility.get_authentication_from_demo()
+        if SqlExcelQuery.is_available(endpoint=info['host'],
+                                      database=info['database'],
+                                      username=info['user'],
+                                      password=info['password'],
+                                      language='en_US'):
+            # The model sql.excel.pdf is available
+            cls.query_name = uuid.uuid4().hex
+            cls.query = SqlExcelQuery(name=cls.query_name,
+                                      category=f'{APP_NAME} {APP_VERSION}',
+                                      endpoint=info['host'],
+                                      database=info['database'],
+                                      username=info['user'],
+                                      password=info['password'],
+                                      language='en_US')
+        else:
+            # The model sql.excel.pdf is not available
+            cls.query = None
+
+    def setUp(self):
+        """
+        Check if the test could be run
+        """
+        if not self.query:
+            self.skipTest('Model sql.excel.pdf is not available')
+
+    def test_01_get_name(self) -> None:
+        """
+        Check the query name
+        """
+        results = self.query.name
+        # Check if the name is not None
+        self.assertIsNotNone(results)
+        # Check if the name is the same
+        self.assertEqual(results, self.query_name)
+
+    def test_02_get_language(self) -> None:
+        """
+        Check the query language
+        """
+        results = self.query.language
+        # Check if the language is not None
+        self.assertIsNotNone(results)
+        # Check if the language is the same
+        self.assertEqual(results, 'en_US')
+
+    def test_03_get_id(self) -> None:
+        """
+        Check the query ID
+        """
+        results = self.query.id
+        # Check if the ID is not None
+        self.assertIsNotNone(results)
+        # Check if the ID is > 0
+        self.assertGreater(results, 0)
+
+    def test_04_get_set_sql(self) -> None:
+        """
+        Get the query SQL text
+        """
+        results = self.query.get_sql()
+        # Check if the query SQL text is not None
+        self.assertIsNotNone(results)
+        # Check if the query SQL text length is = 0
+        self.assertEqual(len(results), 0)
+        # Set new query SQL text
+        sql_text = ('SELECT customer, supplier, COUNT(*) AS count '
+                    'FROM res_partner '
+                    'GROUP BY customer, supplier')
+        results = self.query.set_sql(text=sql_text)
+        # Check if the response is True
+        self.assertEqual(results, True)
+        # Check if the query SQL text is not None
+        results = self.query.get_sql()
+        self.assertIsNotNone(results)
+        # Check if the query SQL text is the expected
+        self.assertEqual(results, sql_text)
+
+    def test_05_get_state(self) -> None:
+        """
+        Get the query state
+        """
+        results = self.query.get_state()
+        # Check if the query state is not None
+        self.assertIsNotNone(results)
+        # Check if the query state is draft
+        self.assertEqual(results, 'draft')
+
+    def test_06_validate(self) -> None:
+        """
+        Set the query state to validate
+        """
+        self.query.validate()
+        # Check if the query state is not None
+        results = self.query.get_state()
+        self.assertIsNotNone(results)
+        # Check if the query state is validate
+        self.assertEqual(results, 'validate')
+
+    def test_07_set_draft(self) -> None:
+        """
+        Set the query state to draft
+        """
+        self.query.set_draft()
+        # Check if the query state is not None
+        results = self.query.get_state()
+        self.assertIsNotNone(results)
+        # Check if the query state is draft
+        self.assertEqual(results, 'draft')
+
+    def test_08_get_set_active(self) -> None:
+        """
+        Get and set the query active state
+        """
+        # Set the query as not active
+        results = self.query.set_active(active=False)
+        self.assertTrue(results)
+        # Check if the query active state is False
+        results = self.query.get_active()
+        self.assertFalse(results)
+        # Set the query as active
+        results = self.query.set_active(active=True)
+        self.assertTrue(results)
+        # Check if the query active state is True
+        results = self.query.get_active()
+        self.assertTrue(results)
+
+    def test_09_execute(self) -> None:
+        """
+        Execute the query
+        """
+        results = self.query.execute()
+        # Check if the query was executed
+        self.assertIsNone(results)
+
+    def test_10_get_file(self) -> None:
+        """
+        Get the query execution results as file
+        """
+        results = self.query.get_file()
+        # Check if the file is not None
+        self.assertIsNotNone(results)
+        # Check if the file is not empty
+        self.assertGreater(len(results), 0)
+
+    def test_11_clear(self) -> None:
+        """
+        Clear the query execution results file
+        """
+        self.query.clear()
+        results = self.query.get_file()
+        # Check if the language is None
+        self.assertIsNone(results)
+
+    def test_12_get_data(self) -> None:
+        """
+        Get the query execution results as data
+        """
+        self.query.execute()
+        results = self.query.get_data()
+        # Check if the results data are not None
+        self.assertIsNotNone(results)
+        # Check if the results have one or more results
+        self.assertGreaterEqual(len(results), 1)
+        # Check if the results data have the expected fields
+        self.assertIn('S.No', results[0])
+        self.assertIn('customer', results[0])
+        self.assertIn('supplier', results[0])
+        self.assertIn('count', results[0])
+        self.assertEqual(len(results[0]), 4)
+
+    def test_13_add_tags(self) -> None:
+        """
+        Add and get tags from the Query
+        """
+        model = self.query.model.get_model(model_name='sql.tags',
+                                           authenticate=False,
+                                           use_existing_uid=True)
+        tag_ids = model.search(filters=[])
+        for tag_id in tag_ids:
+            results = self.query.add_tag(tag_id=tag_id)
+            # Check if the addition was successful
+            self.assertTrue(results)
+        # Check the resulting tags
+        results = self.query.get_tags()
+        # Check the tags list
+        self.assertIsNotNone(results)
+        results = [item['id'] for item in results]
+        for tag_id in tag_ids:
+            self.assertIn(tag_id, results)
+
+    def test_14_delete(self) -> None:
+        """
+        Delete the query
+        """
+        results = self.query.delete()
+        # Check if the deletion was successful
+        self.assertTrue(results)