fixes for serverless APIs + tests

.github/workflows/ci_cd.yml

@@ -152,6 +152,7 @@ jobs:
         if: ${{ !env.ACT }}
         with:
           library-name: ${{ env.PACKAGE_NAME }}
+          token: ${{ secrets.GITHUB_TOKEN }}
 
   upload_dev_docs:
     name: Upload dev documentation

.gitignore

@@ -75,4 +75,3 @@ doc/_build
 *.tiff
 _test_enhanced_images.py
 local_tests/
-*.gz

README.rst

@@ -141,6 +141,81 @@ installation and the test file you are trying to run.
 
 Note that any tests that require Docker will obviously fail.
 
+Creating a Release
+------------------
+
+- Before creating a new branch, make sure your local repository is up to date:
+
+  .. code-block:: bash
+
+      git pull
+
+  This ensures you have the latest changes from the default branch (usually ``main`` or ``develop``).
+
+- Create a new branch for the release:
+
+  .. code-block:: bash
+
+      git checkout -b release/0.10
+
+  **Important:**
+  The release branch must only include the **major** and **minor** version numbers.
+  Do not include the patch version.
+  For example, use ``release/0.10``, not ``release/0.10.0``.
+
+- If creating a **patch release**, do not create a new branch.
+  Instead, reuse the existing ``release/0.10`` branch.
+
+- Update the version number in ``pyproject.toml``:
+
+  If the current version is:
+
+  .. code-block:: toml
+
+      version = "0.10.0.dev0"
+
+  bump it to:
+
+  .. code-block:: toml
+
+      version = "0.10.0"
+
+- **Important:**
+  Every time you create a development (``dev``) release, you should first release the corresponding stable version on PyPI before bumping the development version.
+
+  For example:
+
+  - If you are at ``0.10.0.dev0``, first release ``0.10.0`` on PyPI.
+  - Then, after the release, bump the version to ``0.10.1.dev0``.
+
+  Otherwise, it may feel confusing to have a ``dev`` version without a corresponding stable release.
+
+- Create a commit for the version bump:
+
+  .. code-block:: bash
+
+      git commit -am "MAINT: Bump version to v0.10.0"
+
+- Then push the branch:
+
+  .. code-block:: bash
+
+      git push --set-upstream origin release/0.10
+
+- Create a tag for the release:
+
+  .. code-block:: bash
+
+      git tag v0.10.0
+      git push origin v0.10.0
+
+  **Important:**
+  The release tag must always include the full **major.minor.patch** version number.
+  Always include the ``v`` prefix.
+  For example, use ``v0.10.0``, not ``v0.10``.
+  Creating and pushing the tag automatically triggers the release workflow in GitHub Actions.
+
+
 Dependencies
 ------------
 To use PyDynamicReporting, you must have a locally installed and licensed copy

pyproject.toml

@@ -16,7 +16,7 @@ authors = [
 
 maintainers = [
     {name = "ANSYS, Inc.", email = "pyansys.core@ansys.com"},
-    {name = "Ansys ADR Team", email = "nexus@ansys.com"},
+    {name = "Ansys ADR Team", email = "adrteam@ansys.com"},
 ]
 description = "Python interface to Ansys Dynamic Reporting"
 readme = "README.rst"
@@ -161,7 +161,7 @@ src_paths = ["doc", "src", "tests"]
 
 [tool.codespell]
 ignore-words = "doc/styles/Vocab/ANSYS/accept.txt"
-skip = '*.pyc,*.xml,*.gif,*.png,*.jpg,*.js,*.html,doc/source/examples/**/*.ipynb'
+skip = '*.pyc,*.xml,*.gif,*.png,*.jpg,*.js,*.html,doc/source/examples/**/*.ipynb,*.json,*.gz'
 quiet-level = 3
 
 [tool.bandit]

src/ansys/dynamicreporting/core/__init__.py

@@ -1,6 +1,5 @@
 # Version
 # ------------------------------------------------------------------------------
-from pathlib import Path
 
 try:
     import importlib.metadata as importlib_metadata  # type: ignore

src/ansys/dynamicreporting/core/serverless/adr.py

@@ -415,9 +415,7 @@ def setup(self, collect_static: bool = False) -> None:
         if self._debug is not None:
             overrides["DEBUG"] = self._debug
 
-        # cannot be None
         overrides["MEDIA_ROOT"] = str(self._media_directory)
-
         if self._static_directory is not None:
             overrides["STATIC_ROOT"] = str(self._static_directory)
 
@@ -536,14 +534,19 @@ def close(self):
         # close db connections
         try:
             connections.close_all()
-        except DatabaseError:
+        except DatabaseError:  # pragma: no cover
             pass
         # cleanup temp files
         for tmp_dir in self._tmp_dirs:
             tmp_dir.cleanup()
 
     def backup_database(
-        self, output_directory: str = ".", *, database: str = "default", compress=False
+        self,
+        output_directory: str | Path = ".",
+        *,
+        database: str = "default",
+        compress: bool = False,
+        ignore_primary_keys: bool = False,
     ) -> None:
         if self._in_memory:
             raise ADRException("Backup is not available in in-memory mode.")
@@ -555,21 +558,25 @@ def backup_database(
         # call django management command to dump the database
         timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
         file_path = target_dir / f"backup_{timestamp}.json{'.gz' if compress else ''}"
+        args = [
+            "dumpdata",
+            "--all",
+            "--database",
+            database,
+            "--output",
+            str(file_path),
+            "--verbosity",
+            0,
+            "--natural-foreign",
+        ]
+        if ignore_primary_keys:
+            args.append("--natural-primary")
         try:
-            management.call_command(
-                "dumpdata",
-                "--all",
-                "--database",
-                database,
-                "--output",
-                str(file_path),
-                "--verbosity",
-                0,
-            )
+            management.call_command(*args)
         except Exception as e:
             raise ADRException(f"Backup failed: {e}")
 
-    def restore_database(self, input_file: str, *, database: str = "default") -> None:
+    def restore_database(self, input_file: str | Path, *, database: str = "default") -> None:
         if database != "default" and database not in self._databases:
             raise ADRException(f"{database} must be configured first using the 'databases' option.")
         backup_file = Path(input_file).resolve(strict=True)
@@ -647,10 +654,9 @@ def session_guid(self) -> uuid.UUID:
 
     def create_item(self, item_type: type[Item], **kwargs: Any) -> Item:
         if not issubclass(item_type, Item):
-            raise TypeError(f"{item_type} is not valid")
+            raise TypeError(f"{item_type.__name__} is not a subclass of Item")
         if not kwargs:
             raise ADRException("At least one keyword argument must be provided to create the item.")
-        kwargs["_in_memory"] = self._in_memory
         return item_type.create(
             session=kwargs.pop("session", self._session),
             dataset=kwargs.pop("dataset", self._dataset),
@@ -660,7 +666,7 @@ def create_item(self, item_type: type[Item], **kwargs: Any) -> Item:
     @staticmethod
     def create_template(template_type: type[Template], **kwargs: Any) -> Template:
         if not issubclass(template_type, Template):
-            raise TypeError(f"{template_type} is not valid")
+            raise TypeError(f"{template_type.__name__} is not a subclass of Template")
         if not kwargs:
             raise ADRException(
                 "At least one keyword argument must be provided to create the template."
@@ -681,34 +687,30 @@ def get_report(**kwargs) -> Template:
         try:
             return Template.get(parent=None, **kwargs)
         except Exception as e:
-            raise e
+            raise ADRException(f"Report not found: {e}")
 
     @staticmethod
     def get_reports(*, fields: list | None = None, flat: bool = False) -> ObjectSet | list:
         # return list of reports by default.
         # if fields are mentioned, return value list
-        try:
-            out = Template.filter(parent=None)
-            if fields:
-                out = out.values_list(*fields, flat=flat)
-        except Exception as e:
-            raise e
-
+        out = Template.filter(parent=None)
+        if fields:
+            out = out.values_list(*fields, flat=flat)
         return out
 
-    def get_list_reports(self, *, r_type: str = "name") -> ObjectSet | list:
+    def get_list_reports(self, r_type: str | None = "name") -> ObjectSet | list:
         supported_types = ("name", "report")
-        if r_type not in supported_types:
+        if r_type and r_type not in supported_types:
             raise ADRException(f"r_type must be one of {supported_types}")
-        if r_type == "name":
-            return self.get_reports(
-                fields=[
-                    r_type,
-                ],
-                flat=True,
-            )
-        else:
+        if not r_type or r_type == "report":
             return self.get_reports()
+        # if r_type == "name":
+        return self.get_reports(
+            fields=[
+                r_type,
+            ],
+            flat=True,
+        )
 
     def render_report(
         self, *, context: dict | None = None, item_filter: str = "", **kwargs: Any
@@ -732,7 +734,9 @@ def query(
         **kwargs: Any,
     ) -> ObjectSet:
         if not issubclass(query_type, (Item, Template, Session, Dataset)):
-            raise TypeError(f"{query_type} is not valid")
+            raise TypeError(
+                f"'{query_type.__name__}' is not a type of Item, Template, Session, or Dataset"
+            )
         return query_type.find(query=query, **kwargs)
 
     @staticmethod
@@ -744,7 +748,7 @@ def create_objects(
             raise ADRException("objects must be an iterable")
         count = 0
         for obj in objects:
-            if kwargs.get("using", "default") != obj.db:
+            if obj.db and kwargs.get("using", "default") != obj.db:
                 # required if copying across databases
                 obj.reinit()
             obj.save(**kwargs)

src/ansys/dynamicreporting/core/serverless/base.py

@@ -2,6 +2,7 @@
 from collections.abc import Iterable
 from dataclasses import dataclass, field
 from dataclasses import fields as dataclass_fields
+from enum import Enum
 import importlib
 import inspect
 from itertools import chain
@@ -563,3 +564,13 @@ def __set__(self, obj, value):
     @abstractmethod
     def process(self, value, obj):
         pass  # pragma: no cover
+
+
+class StrEnum(str, Enum):
+    """Enum with a str mixin."""
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value