tol-sdk 1.8.5__tar.gz → 1.8.6__tar.gz

{tol_sdk-1.8.5/src/tol_sdk.egg-info → tol_sdk-1.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tol-sdk
-Version: 1.8.5
+Version: 1.8.6
 Summary: SDK for interaction with ToL, Sanger and external services
 Author-email: ToL Platforms Team <tol-platforms@sanger.ac.uk>
 License: MIT

{tol_sdk-1.8.5 → tol_sdk-1.8.6}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tol-sdk"
-version = "1.8.5"
+version = "1.8.6"
 description = "SDK for interaction with ToL, Sanger and external services"
 readme = "README.md"
 authors = [

{tol_sdk-1.8.5 → tol_sdk-1.8.6}/src/tol/api_base/system.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: MIT
 
+import glob
+
 from flask import Blueprint
 
 
@@ -16,6 +18,7 @@ def system_blueprint(
     By default includes:
     - /healthz      - used for health probes in kubernetes
     - /environment  - indicates the deployment environment
+    - /package-versions  - indicates the deployment package versions
 
     Parameters:
     - url_prefix    - the prefix under which to serve this blueprint's
@@ -40,4 +43,19 @@ def system_blueprint(
             k: env_vars.get(v) for k, v in env_map.items()
         }, 200
 
+    @system_blueprint.route('/package-versions')
+    def package_versions():
+        glob_paths = glob.glob('./**/requirements.txt', recursive=True)
+        with open(glob_paths[0], 'r') as f:
+            requirements = f.readlines()
+            for requirement in requirements:
+                if 'tol-sdk' in requirement:
+                    tol_sdk_version = requirement.split('==')[1].strip()
+                    break
+            f.close()
+
+        result = {'tol_sdk': tol_sdk_version}
+
+        return result, 200
+
     return system_blueprint

{tol_sdk-1.8.5 → tol_sdk-1.8.6}/src/tol/api_client/api_datasource.py

@@ -35,6 +35,7 @@ from ..core.operator import (
     Upserter,
 )
 from ..core.relationship import RelationshipConfig
+from ..core.requested_fields import ReqFieldsTree, requested_fields_to_tree
 
 if typing.TYPE_CHECKING:
     from ..core.session import OperableSession
@@ -140,24 +141,38 @@ class ApiDataSource(
         object_ids: Iterable[str],
         session: Optional[OperableSession] = None,
         requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> Iterable[Optional[DataObject]]:
 
         client = self.__client_factory()
+        # This would be better handled in the decorator but there is a slight
+        # difference in handling here with the requested_tree when requested_fields is None
+        requested_tree = (
+            ReqFieldsTree(
+                object_type,
+                self,
+                requested_fields=requested_fields,
+            )
+            if object_type
+            else None
+        )
+
         json_responses = (
             client.get_detail(
                 object_type,
                 id_,
-                requested_fields=requested_fields,
+                requested_tree=requested_tree,
             )
             for id_ in object_ids
         )
-        json_converter = self.__jc_factory(object_type, requested_fields)
+        json_converter = self.__jc_factory(object_type, requested_tree)
         return (
             json_converter.convert(r)
             if r is not None else None
             for r in json_responses
         )
 
+    @requested_fields_to_tree
     @validate('listGet')
     def get_list_page(
         self,
@@ -168,6 +183,7 @@ class ApiDataSource(
         sort_by: Optional[str] = None,
         session: Optional[OperableSession] = None,
         requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> tuple[Iterable[DataObject], int]:
 
         filter_string = self.__get_filter_string(object_filters)
@@ -177,28 +193,31 @@ class ApiDataSource(
             page_size,
             filter_string=filter_string,
             sort_string=sort_by,
-            requested_fields=requested_fields,
+            requested_tree=requested_tree,
         )
-        return self.__jc_factory(object_type, requested_fields).convert_list(transfer)
 
+        return self.__jc_factory(object_type, requested_tree).convert_list(transfer)
+
+    @requested_fields_to_tree
     def get_list(
         self,
         object_type: str,
         object_filters: Optional[DataSourceFilter] = None,
         session: Optional[OperableSession] = None,
         requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> Iterable[DataObject]:
         if self.__can_cursor(object_type, object_filters):
             return self._get_list_by_cursor(
                 object_type,
                 object_filters,
-                requested_fields=requested_fields,
+                requested_tree=requested_tree,
             )
         else:
             return self.__get_list_regular(
                 object_type,
                 object_filters,
-                requested_fields=requested_fields,
+                requested_tree=requested_tree,
             )
 
     @validate('count')
@@ -263,7 +282,7 @@ class ApiDataSource(
         object_filters: Optional[DataSourceFilter] = None,
         search_after: list[str] | None = None,
         session: Optional[OperableSession] = None,
-        requested_fields: list[str] | None = None
+        requested_tree: ReqFieldsTree | None = None,
     ) -> tuple[Iterable[DataObject], list[str] | None]:
 
         filter_string = self.__get_filter_string(object_filters)
@@ -272,9 +291,10 @@ class ApiDataSource(
             page_size,
             search_after,
             filter_string=filter_string,
-            requested_fields=requested_fields,
+            requested_tree=requested_tree,
         )
-        return self.__jc_factory(object_type, requested_fields).convert_cursor_page(transfer)
+
+        return self.__jc_factory(object_type, requested_tree).convert_cursor_page(transfer)
 
     @validate('delete')
     def delete(
@@ -436,13 +456,14 @@ class ApiDataSource(
         self,
         object_type: str,
         object_filters: Optional[DataSourceFilter],
-        requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> Iterable[DataObject]:
 
         page = 1
         page_size = self.get_page_size()
         client = self.__client_factory()
-        jc_converter = self.__jc_factory(object_type, requested_fields)
+
+        jc_converter = self.__jc_factory(object_type, requested_tree)
         filter_string = self.__get_filter_string(object_filters)
 
         while True:
@@ -451,7 +472,7 @@ class ApiDataSource(
                 page,
                 page_size,
                 filter_string=filter_string,
-                requested_fields=requested_fields,
+                requested_tree=requested_tree,
             )
             (results_page, _) = jc_converter.convert_list(transfer)
 

{tol_sdk-1.8.5 → tol_sdk-1.8.6}/src/tol/api_client/client.py

@@ -11,6 +11,7 @@ from .converter import JsonApiTransfer, JsonRelationshipConfig
 from ..core import HttpClient
 from ..core.datasource_error import DataSourceError
 from ..core.operator import OperatorDict
+from ..core.requested_fields import ReqFieldsTree
 
 
 class JsonApiClient(HttpClient):
@@ -43,7 +44,7 @@ class JsonApiClient(HttpClient):
         self,
         object_type: str,
         object_id: str,
-        requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> Optional[JsonApiTransfer]:
         """
         Gets a single JSON:API transfer for the object of specified
@@ -56,7 +57,7 @@ class JsonApiClient(HttpClient):
         return self.__fetch_detail(
             url,
             params={
-                'requested_fields': requested_fields,
+                'requested_fields': requested_tree.to_paths() if requested_tree else None,
             },
             headers=headers,
         )
@@ -68,7 +69,7 @@ class JsonApiClient(HttpClient):
         page_size: int,
         filter_string: Optional[str] = None,
         sort_string: Optional[str] = None,
-        requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> JsonApiTransfer:
         """
         Gets a (paged) list-JSON:API transfer for the objects of specified
@@ -81,7 +82,7 @@ class JsonApiClient(HttpClient):
             page_size=page_size,
             filter=filter_string,
             sort_by=sort_string,
-            requested_fields=requested_fields
+            requested_fields=requested_tree.to_paths() if requested_tree else None,
         )
         headers = self._merge_headers()
         return self.__fetch_list(
@@ -157,7 +158,7 @@ class JsonApiClient(HttpClient):
         page_size: int,
         search_after: list[str] | None,
         filter_string: Optional[str] = None,
-        requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> JsonApiTransfer:
         """Cursor-pagination."""
 
@@ -165,7 +166,7 @@ class JsonApiClient(HttpClient):
         params = self.__no_none_value_dict(
             filter=filter_string,
             page_size=page_size,
-            requested_fields=requested_fields,
+            requested_fields=requested_tree.to_paths() if requested_tree else None,
         )
         headers = self._merge_headers()
         body = {'search_after': search_after}
@@ -462,5 +463,7 @@ class JsonApiClient(HttpClient):
         for k, v in kwargs.items():
             if v is None:
                 continue
+            if isinstance(v, list) and not v:
+                continue
             str_params[k] = ','.join([str(x) for x in v]) if isinstance(v, list) else str(v)
         return str_params

{tol_sdk-1.8.5 → tol_sdk-1.8.6}/src/tol/api_client/factory.py

@@ -59,23 +59,12 @@ class _ConverterFactory:
     def json_converter_factory(
         self,
         object_type: str | None = None,
-        requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree | None = None,
     ) -> JsonConverterFactory:
         """
         Returns an instantiated `JsonApiConverter`.
         """
-
-        req_fields_tree = (
-            ReqFieldsTree(
-                object_type,
-                self.__data_source,
-                requested_fields=requested_fields,
-            )
-            if object_type
-            else None
-        )
-
-        parser = DefaultParser(self.__ds_dict, req_fields_tree)
+        parser = DefaultParser(self.__ds_dict, requested_tree)
         return JsonApiConverter(parser)
 
     @property

{tol_sdk-1.8.5 → tol_sdk-1.8.6}/src/tol/core/requested_fields.py

@@ -11,6 +11,26 @@ from .operator import Relational
 from .relationship import RelationshipConfig
 
 
+def requested_fields_to_tree(func):
+    """
+    Allows `requested_fields` keyword arguments to be supplied to methods if a
+    `requested_tree` object has not been given.
+    """
+
+    def wrapper(self, tablename, *args, **kwargs):
+        if 'requested_fields' in kwargs:
+            if 'requested_tree' in kwargs:
+                msg = 'Both requested_fields and requested_tree arguments given'
+                raise TypeError(msg)
+            flds = kwargs.pop('requested_fields')
+            kwargs['requested_tree'] = ReqFieldsTree(
+                tablename, self, requested_fields=flds
+            )
+        return func(self, tablename, *args, **kwargs)
+
+    return wrapper
+
+
 class ReqFieldsTree:
     """
     Acts as a template for which related objects and attributes to fetch from

tol_sdk-1.8.6/src/tol/dummy/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2026 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+from .dummy_datasource import DummyDataSource  # noqa
+from .factory import create_dummy_datasource  # noqa

tol_sdk-1.8.6/src/tol/dummy/client.py

@@ -0,0 +1,88 @@
+# SPDX-FileCopyrightText: 2024 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+import string
+from typing import Iterable, Optional
+
+from .converter import DummyTransfer
+from ..core import HttpClient
+
+
+class DummyClient(HttpClient):
+    """
+    Simulates dummy objects retrieval from a remote API.
+    """
+
+    def __init__(
+        self,
+    ) -> None:
+        super().__init__()
+
+    def get_detail(
+        self,
+        object_type: str,
+        object_ids: Iterable[str]
+    ) -> Optional[DummyTransfer]:
+        """
+        Gets a list of Dummy transfers for the objects of specified
+        `object_type` and `object_id`, or returns None if not found.
+        """
+        return self.__get_detail_data(object_type, object_ids)
+
+    def get_list(
+        self,
+        object_type: str
+    ) -> Optional[DummyTransfer]:
+        return self.__get_detail_data(object_type, range(10000))
+
+    def __get_detail_data(
+        self,
+        object_type: str,
+        object_ids: Iterable[str]
+    ) -> Optional[DummyTransfer]:
+        if object_type == 'category':
+            return self.__get_detail_category(object_type, object_ids)
+        return self.__get_detail_record(object_type, object_ids)
+
+    def __get_detail_record(
+        self,
+        object_type: str,
+        object_ids: Iterable[str]
+    ) -> Optional[DummyTransfer]:
+        """
+        Gets a list of dummy objects
+        """
+        ret = []
+        for object_id in object_ids:
+            if object_id < 10000:
+                ret.append({
+                    'id': object_id,
+                    'little_string': ['a', 'b', 'c'][int(object_id) % 3],
+                    'big_string': string.ascii_letters[int(object_id) % 52],
+                    'int': object_id,
+                    'bool': int(object_id) % 2 == 0,
+                    'date': f'2024-01-{(int(object_id) % 28) + 1:02d}',
+                    'type': object_type,
+                    'category': ['cat1', 'cat2', 'cat3', 'cat4'][int(object_id) % 4],
+                })
+            else:
+                ret.append(None)
+        return ret
+
+    def __get_detail_category(
+        self,
+        object_type: str,
+        object_ids: Iterable[str]
+    ) -> Optional[DummyTransfer]:
+        """
+        Gets a list of dummy objects
+        """
+        ret = []
+        for object_id in object_ids:
+            ret.append({
+                'id': object_id,
+                'name': object_id.upper(),
+                'type': object_type
+            })
+        return ret

tol_sdk-1.8.6/src/tol/dummy/converter.py

@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: 2024 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+from typing import Any, List, Optional
+
+from .parser import Parser
+from ..core import DataObject
+
+
+DummyObject = dict[str, Any]
+DummyTransfer = List[DummyObject]
+
+
+class DummyConverter():
+
+    """
+    Converts from Dummy transfers to instances of
+    `DataObject`.
+    """
+
+    def __init__(
+        self,
+        parser: Parser
+    ) -> None:
+
+        self.__parser = parser
+
+    def convert(self, input_: DummyTransfer) -> DataObject:
+        """
+        Converts a DummyTransfer containing a detail (single) result
+        """
+        return self.__parser.parse(input_)
+
+    def convert_list(
+        self,
+        input_: DummyTransfer
+    ) -> tuple[list[DataObject], Optional[int]]:
+        """
+        Converts a DummyTransfer containing a list of results. Also
+        returns a count of the total results meeting.
+        """
+
+        return [
+            self.__parser.parse(json_obj)
+            for json_obj in input_
+            if json_obj is not None
+        ], None

tol_sdk-1.8.6/src/tol/dummy/dummy_datasource.py

@@ -0,0 +1,105 @@
+# SPDX-FileCopyrightText: 2026 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import typing
+from functools import cache
+from typing import Callable, Iterable, Optional
+
+from .client import DummyClient
+from .converter import (
+    DummyConverter
+)
+from ..core import DataObject, DataSource, DataSourceError, DataSourceFilter
+from ..core.operator import (
+    DetailGetter,
+    ListGetter
+)
+
+if typing.TYPE_CHECKING:
+    from ..core.session import OperableSession
+
+ClientFactory = Callable[[], DummyClient]
+DummyConverterFactory = Callable[[], DummyConverter]
+
+
+class DummyDataSource(
+    DataSource,
+
+    # the supported operators
+    DetailGetter,
+    ListGetter
+):
+    """
+    A `DataSource` that outputs dummy data.
+
+    Developers should likely use `create_dummy_datasource`
+    instead of this directly.
+    """
+
+    def __init__(
+        self,
+        client_factory: ClientFactory,
+        dummy_converter_factory: DummyConverterFactory
+    ) -> None:
+
+        self.__client_factory = client_factory
+        self.__dummy_converter_factory = dummy_converter_factory
+        super().__init__({})
+
+    @property
+    @cache
+    def attribute_types(self) -> dict[str, dict[str, str]]:
+        return {
+            'record': {
+                'big_string': 'str',
+                'little_string': 'str',
+                'bool': 'bool',
+                'date': 'datetime',
+                'int': 'int',
+                'list': 'list[str]'
+            },
+            'category': {
+                'name': 'str'
+            }
+        }
+
+    @property
+    @cache
+    def supported_types(self) -> list[str]:
+        return list(
+            self.attribute_types.keys()
+        )
+
+    def get_by_id(
+        self,
+        object_type: str,
+        object_ids: Iterable[str],
+        **kwargs
+    ) -> Iterable[Optional[DataObject]]:
+        if object_type not in self.supported_types:
+            raise DataSourceError(f'{object_type} is not supported')
+
+        client = self.__client_factory()
+        dummy_response = client.get_detail(object_type, object_ids)
+        dummy_converter = self.__dummy_converter_factory()
+
+        converted_objects, _ = dummy_converter.convert_list(dummy_response) \
+            if dummy_response is not None else ([], 0)
+        yield from self.sort_by_id(converted_objects, object_ids)
+
+    def get_list(
+        self,
+        object_type: str,
+        object_filters: Optional[DataSourceFilter] = None,
+        session: Optional[OperableSession] = None
+    ) -> Iterable[DataObject]:
+        if object_filters:
+            raise DataSourceError('Filtering is not supported')
+        objects = self.__client_factory().get_list(
+            object_type
+        )
+        converted_objects, _ = self.__dummy_converter_factory().convert_list(objects)
+        return iter(converted_objects)

tol_sdk-1.8.6/src/tol/dummy/factory.py

@@ -0,0 +1,95 @@
+# SPDX-FileCopyrightText: 2024 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+from collections.abc import Mapping
+from typing import Callable, Iterator, Optional
+
+from .client import DummyClient
+from .converter import (
+    DummyConverter
+)
+from .dummy_datasource import (
+    DummyConverterFactory,
+    DummyDataSource
+)
+from .parser import DefaultParser
+from ..core import DataSource
+
+
+class _DummyDSDict(Mapping):
+    def __init__(self, api_ds: DummyDataSource) -> None:
+        self.__ds = api_ds
+
+    def __getitem__(self, __k: str) -> DummyDataSource:
+        if __k not in self.__ds.supported_types:
+            raise KeyError()
+        return self.__ds
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.__ds.supported_types)
+
+    def __len__(self) -> int:
+        return len(self.__ds.supported_types)
+
+
+class _ConverterFactory:
+    """
+    Manges the instantation of:
+
+    - `DummyConverter`
+    """
+
+    def __init__(self) -> None:
+        self.__data_source: Optional[DataSource] = None
+
+    @property
+    def data_source(self) -> Optional[DataSource]:
+        return self.__data_source
+
+    @data_source.setter
+    def data_source(
+        self,
+        ds: DataSource
+    ) -> None:
+
+        self.__data_source = ds
+
+    def dummy_converter_factory(self) -> DummyConverterFactory:
+        """
+        Returns an instantiated `DummyConverter`.
+        """
+
+        parser = DefaultParser(self.__ds_dict)
+        return DummyConverter(parser)
+
+    @property
+    def __ds_dict(self) -> dict[str, DataSource]:
+        return _DummyDSDict(self.data_source)
+
+
+def _get_client_factory() -> Callable[[], DummyClient]:
+    """
+    A resonable default for creating
+    a `DummyClient` instance
+    """
+
+    return lambda: DummyClient()
+
+
+def create_dummy_datasource() -> DummyDataSource:
+    """
+    Instantiates `DummyDataSource`
+    """
+
+    client_factory = _get_client_factory()
+    manager = _ConverterFactory()
+
+    dummy_ds = DummyDataSource(
+        client_factory,
+        manager.dummy_converter_factory
+    )
+
+    manager.data_source = dummy_ds
+
+    return dummy_ds