Merge: PR #13 Prerelease optimizations (performance and introspection).

Final prerelease optimizations

Author: buddemat

src/cadenzaanalytics/cadenza_analytics_extension_service.py

@@ -1,9 +1,8 @@
 """Provides a service which encapsulates the configuration and execution of individual analytics extensions.
 Runs an HTTP server which executes the individual extension's analytics function and serves an extension
 discovery endpoint."""
+import inspect
 import json
-import errno
-import sys
 from typing import Optional
 
 from flask import Flask, Response
@@ -44,24 +43,24 @@ def add_analytics_extension(self, analytics_extension: CadenzaAnalyticsExtension
         ----------
         analytics_extension : CadenzaAnalyticsExtension
             The analytics extension to be added.
-        """
 
+        Raises
+        ------
+        ValueError
+            If the relative path is already in use or the analytics function has an invalid signature.
+        """
         self.logger.info('Registering extension "%s" on relative path "%s"...',
                 analytics_extension.print_name,
                 analytics_extension.relative_path
             )
 
         # perform some validation checks
         if analytics_extension.relative_path in [x.relative_path for x in self._analytics_extensions]:
-            self.logger.critical('Relative path "%s" is already in use by another extension. Exiting...',
-                    analytics_extension.relative_path)
-            sys.exit(errno.EINTR)
-        if analytics_extension._analytics_function.__code__.co_argcount != 1: # pylint: disable=W0212
-            self.logger.critical('The analytics function "%s()" takes 1 positional arguments, but %s given. Exiting...',
-                    analytics_extension._analytics_function.__name__,            # pylint: disable=W0212
-                    analytics_extension._analytics_function.__code__.co_argcount # pylint: disable=W0212
-                )
-            sys.exit(errno.EINTR)
+            msg = f'Relative path "{analytics_extension.relative_path}" is already in use by another extension.'
+            self.logger.critical(msg)
+            raise ValueError(msg)
+
+        self._validate_analytics_function(analytics_extension._analytics_function)  # pylint: disable=W0212
 
         self._analytics_extensions.append(analytics_extension)
 
@@ -98,6 +97,30 @@ def app(self) -> Flask:
         """
         return self._app
 
+    def _validate_analytics_function(self, func) -> None:
+        """Validate that analytics function has correct signature.
+
+        Parameters
+        ----------
+        func : Callable
+            The analytics function to validate.
+
+        Raises
+        ------
+        ValueError
+            If the function does not accept exactly 1 positional argument.
+        """
+        try:
+            sig = inspect.signature(func)
+            params = [p for p in sig.parameters.values()
+                      if p.kind in (inspect.Parameter.POSITIONAL_ONLY,
+                                    inspect.Parameter.POSITIONAL_OR_KEYWORD)]
+            if len(params) != 1:
+                raise ValueError(f"Function must accept exactly 1 positional argument, got {len(params)}")
+        except (ValueError, TypeError) as err:
+            self.logger.critical("Invalid analytics function: %s", err)
+            raise ValueError(str(err)) from err
+
     def _list_extensions(self) -> Response:
         """List all registered analytics extensions.
 

src/cadenzaanalytics/data/attribute_group.py

@@ -8,8 +8,8 @@
 class AttributeGroup(DataObject):
     """Defines a group of attributes with common characteristics for input data.
 
-    Attribute groups specify accepted (non-geometry) data types, cardinality 
-    constraints, and optionally geometry types and spatial reference system for 
+    Attribute groups specify accepted (non-geometry) data types, cardinality
+    constraints, and optionally geometry types and spatial reference system for
     data columns.
     """
 

src/cadenzaanalytics/data/parameter.py

@@ -49,7 +49,7 @@ def __init__(self, *,
             List of allowed values for SELECT parameters.
         required : bool, optional
             Whether the parameter is required, by default False.
-            For parameter type boolean, required=True makes submitting the value 
+            For parameter type boolean, required=True makes submitting the value
             True mandatory.
         default_value : Any, optional
             Default value if the user doesn't provide one.

src/cadenzaanalytics/request/request_metadata.py

@@ -23,6 +23,12 @@ def __init__(self, request_metadata: dict) -> None:
         self._columns = [ColumnMetadata._from_dict(column)
                          for column
                          in RequestMetadata._parse_columns(request_metadata)]
+        # Build index for O(1) lookups by column name
+        self._columns_by_name: Dict[str, ColumnMetadata] = {col.name: col for col in self._columns}
+        # Build groups index once at initialization
+        self._groups: Dict[str, List[ColumnMetadata]] = {}
+        for column in self._columns:
+            self._groups.setdefault(column.attribute_group_name, []).append(column)
 
     @staticmethod
     def _parse_columns(request_metadata: dict) -> List[dict]:
@@ -42,26 +48,26 @@ def __getitem__(self, key: str) -> ColumnMetadata:
         Returns
         -------
         ColumnMetadata
-            Metadata for the column
-        """
-
-        for column in self._columns:
-            if column.name == key:
-                return column
+            Metadata for the column.
 
-        raise KeyError(f"Column '{key}' not found.")
+        Raises
+        ------
+        KeyError
+            If no column with the given name exists.
+        """
+        try:
+            return self._columns_by_name[key]
+        except KeyError:
+            raise KeyError(f"Column '{key}' not found.") from None
 
     def __iter__(self) -> Iterator[str]:
         return iter(c.name for c in self._columns)
 
     def __len__(self) -> int:
         return len(self._columns)
 
-    def __contains__(self, key: str) -> bool:
-        for column in self._columns:
-            if column.name == key:
-                return True
-        return False
+    def __contains__(self, key: object) -> bool:
+        return key in self._columns_by_name
 
     @property
     def ids(self) -> Optional[List[ColumnMetadata]]:
@@ -96,11 +102,7 @@ def groups(self) -> Dict[str, List[ColumnMetadata]]:
             A dictionary where the keys are the attribute group names and values are lists of corresponding
              column metadata objects.
         """
-        grouped_columns = {}
-        for column in self._columns:
-            grouped_columns.setdefault(column.attribute_group_name, []).append(column)
-
-        return grouped_columns
+        return self._groups
 
     @property
     def columns(self) -> List[ColumnMetadata]: