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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tol-sdk
-Version: 1.8.3
+Version: 1.8.5
 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.3 → tol_sdk-1.8.5}/pyproject.toml

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

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

@@ -206,7 +206,7 @@ class JsonApiClient(HttpClient):
         )
 
         headers = self._merge_headers()
-        session = self._get_session()
+        session = self.get_session()
         r = session.post(
             url,
             headers=headers,
@@ -228,7 +228,7 @@ class JsonApiClient(HttpClient):
 
         url = self.__insert_url(object_type)
         headers = self._merge_headers()
-        session = self._get_session()
+        session = self.get_session()
         r = session.post(url, headers=headers, json=transfer)
         self.__assert_no_error(r)
         return r.json()

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/api_client/view.py

@@ -197,7 +197,7 @@ class DefaultView(View):
             sub_tree = tree.get_sub_tree(rel)
             if sub_tree and rel in data_object._to_many_objects:
                 many_obj = data_object._to_many_objects.get(rel)
-                to_many[rel] = [self.__dump_stub(x, rel) for x in many_obj]
+                to_many[rel] = {'data': [self.__dump_stub(x, rel) for x in many_obj]}
                 for obj in many_obj:
                     included.add_dump(self.__dump_object(obj, included, sub_tree))
             elif quoted_id:

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/core/http_client.py

@@ -55,7 +55,7 @@ class HttpClient:
             **__empty_if_none(self.__token)
         }
 
-    def _get_session(self) -> requests.Session:
+    def get_session(self) -> requests.Session:
 
         cert_path = os.path.join(
             os.path.dirname(__file__),
@@ -74,7 +74,7 @@ class HttpClient:
         """
         Attempts a call to the endpoint 5 times, with a delay of 1 second
         """
-        session = self._get_session()
+        session = self.get_session()
 
         retry_strategy = Retry(
             total=self.__retries,

tol_sdk-1.8.5/src/tol/flows/converters/time_string_to_time.py

@@ -0,0 +1,35 @@
+# SPDX-FileCopyrightText: 2025 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+import re
+from datetime import time
+
+from tol.core import DataObject
+
+
+class Converter:
+    def convert(self, obj):
+        raise NotImplementedError()
+
+
+class TimeStringToTimeConverter(Converter):
+    """
+    Converts string fields representing time in HH:MM (24-hour) format to Python time objects.
+    If the string is not in HH:MM, tries to append ':00' and parse as HH:MM:SS.
+    """
+    def __init__(self, field: str):
+        self.field = field
+
+    def convert(self, obj: DataObject) -> DataObject:
+        value = obj.attributes.get(self.field)
+        if isinstance(value, str):
+            match = re.match(r'^(\d{1,2}):(\d{2})(?::(\d{2}))?$', value)
+            if match:
+                h, m = int(match.group(1)), int(match.group(2))
+                s = int(match.group(3)) if match.group(3) else 0
+                try:
+                    obj.attributes[self.field] = time(h, m, s)
+                except ValueError:
+                    pass
+        return obj

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/sql/auth/blueprint.py

@@ -22,6 +22,7 @@ from ...api_base.auth import (
 )
 from ...api_base.auth.abc import AuthorisationManager
 from ...api_base.misc import AuthContext
+from ...core import HttpClient
 
 
 class DbAuthManager(AuthManager):
@@ -194,7 +195,12 @@ class DbAuthManager(AuthManager):
         Raises:
             requests.HTTPError: If the revocation request fails
         """
-        r = requests.post(
+
+        client = HttpClient()
+
+        session = client.get_session()
+
+        r = session.post(
             self.__config.revoke_url,
             data={
                 'token': token,

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/validators/__init__.py

@@ -21,4 +21,6 @@ from .unique_whole_organisms import UniqueWholeOrganismsValidator  # noqa
 from .interfaces import Condition  # noqa
 from .min_one_valid_value import MinOneValidValueValidator   # noqa
 from .value_check import ValueCheckValidator  # noqa
+from .branching import BranchingValidator  # noqa
 from .unique_value_check import UniqueValueCheckValidator  # noqa
+from .date_sorting import DateSortingValidator # noqa

tol_sdk-1.8.5/src/tol/validators/branching.py

@@ -0,0 +1,160 @@
+# SPDX-FileCopyrightText: 2026 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+import importlib
+from dataclasses import dataclass
+from typing import Dict, List, cast
+
+from tol.core import DataObject
+from tol.core.validate import ValidationResult, Validator
+
+from .interfaces import Condition, ConditionDict, ConditionEvaluator
+
+
+Subvalidation = Dict[str, ConditionDict | str | Dict]
+
+
+class BranchingValidator(Validator, ConditionEvaluator):
+    """
+    This validator is configured with a list of conditions.
+    If a condition passes, the corresponding sub-validator will be run.
+    """
+    @dataclass(slots=True, frozen=True, kw_only=True)
+    class Config:
+        """
+        ```
+        validations=[
+            {
+                'condition': {
+                    'field': 'column_name',
+                    'operator': '==',
+                    'value': 'expected_value',
+                },
+                'module': '<path.to.module>',
+                'class_name': '<path.to.ValidatorClass>',
+                'config_details': { ... },
+            },
+            {
+                ...
+            }
+        ]
+        ```
+        """
+        validations: List[Subvalidation]
+
+    __slots__ = ['__config', '_cached_validators']
+    __config: Config
+    _cached_validators: Dict[int, Validator]
+    """
+    Stores all sub-validators that have already been seen so that they can be used again.
+    Their keys are their indexes in the `validations` list in the validator config
+    """
+
+    def __init__(
+        self,
+        config: Config,
+        **kwargs
+    ) -> None:
+        super().__init__()
+
+        del kwargs
+        self.__config = config
+        self._cached_validators = {}
+
+    def _validate_data_object(
+        self,
+        obj: DataObject
+    ) -> None:
+        for subvalidator_index, subvalidation in enumerate(self.__config.validations):
+            # Do not run this sub-validation if its condition does not pass
+            condition_dict = cast(ConditionDict, subvalidation['condition'])
+            if not self._does_condition_pass(Condition.from_dict(condition_dict), obj):
+                continue
+
+            # Obtain validator, either from cache or anew
+            validator: Validator
+            if subvalidator_index in self._cached_validators:
+                # Use existing validator to perform subvalidation
+                validator = self._cached_validators[subvalidator_index]
+            else:
+                # Create a new validator and use that for the subvalidation
+                validator = self.__instantiate_validator(subvalidation)
+
+                # Add the new validator to the store of cached validators
+                self._cached_validators[subvalidator_index] = validator
+
+            # Validate data object
+            validator._validate_data_object(obj)
+
+            # At this point, I initially added `break` so that once a condition passed, the rest
+            # did not need to be checked. However, I decided against it because it is more flexible
+            # to have the opportunity to allow multiple conditions to pass, and thus execute
+            # multiple subvalidations, on the same `DataObject` in the same iteration
+
+    def __instantiate_validator(self, subvalidation: Subvalidation) -> Validator:
+        # Before attempting to extract items from the subvalidation, ensure all of the required
+        # keys are there and that they contain values of the correct types.
+        # This allows the dictionary to be safely queried thereafter
+        try:
+            # Accessing with square brackets will also check whether the key exists or not
+            if not isinstance(subvalidation['module'], str):
+                raise TypeError('module')
+            elif not isinstance(subvalidation['class_name'], str):
+                raise TypeError('class_name')
+        except (KeyError, TypeError) as e:
+            # Make errors more specific to validators
+            if isinstance(e, KeyError):
+                raise KeyError(
+                    f'Invalid config in BranchingValidator: `{e.args[0]}` not found'
+                )
+            else:
+                raise TypeError(
+                    f'Invalid config in BranchingValidator: '
+                    f'`{e.args[0]}` contains an erroneous value type'
+                )
+
+        # Dynamically retrieve the validator class
+        validator_module = importlib.import_module(subvalidation['module'])
+        validator_class = getattr(validator_module, subvalidation['class_name'])
+
+        # Construct and return the new validator
+        validator_config = validator_class.Config(
+            subvalidation['config_details']
+        )
+        return validator_class(
+            config=validator_config,
+        )
+
+    @property
+    def results(self) -> List[ValidationResult]:
+        """
+        Fetches results from all sub-validators, collated into a single list
+        """
+        return [
+            result
+            for validator in self._cached_validators.values()
+            for result in validator.results
+        ]
+
+    @property
+    def warnings(self) -> List[ValidationResult]:
+        """
+        Fetches warnings from all sub-validators, collated into a single list
+        """
+        return [
+            warning
+            for validator in self._cached_validators.values()
+            for warning in validator.warnings
+        ]
+
+    @property
+    def errors(self) -> List[ValidationResult]:
+        """
+        Fetches errors from all sub-validators, collated into a single list
+        """
+        return [
+            error
+            for validator in self._cached_validators.values()
+            for error in validator.errors
+        ]

tol_sdk-1.8.5/src/tol/validators/date_sorting.py

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: 2026 Genome Research Ltd.
+#
+# SPDX-License-Identifier: MIT
+
+from dataclasses import dataclass
+from datetime import date, datetime
+
+from tol.core import Validator
+from tol.core.data_object import DataObject
+
+
+class DateSortingValidator(Validator):
+    """
+    Validates an incoming stream of `DataObject` instances.
+    For each data object (sample) check the collection date
+    is not preceding the plating date
+    """
+    @dataclass(slots=True, frozen=True, kw_only=True)
+    class Config:
+        dates: list[str]
+
+    __slots__ = ['__config']
+    __config: Config
+
+    def __init__(self, config: Config, **kwargs) -> None:
+        super().__init__()
+        self.__config = config
+
+    def _validate_data_object(self, obj: DataObject) -> None:
+        # This function is used to check if the dates obtained
+        # are in the standard format and the date of collection
+        # is not preceding the date of plating
+
+        previous_date = None
+
+        for date_field in self.__config.dates:
+            date_value = obj.get_field_by_name(date_field)
+
+            # Validate that the value is a date or datetime object
+            if not isinstance(date_value, (date, datetime)):
+                self.add_error(
+                    object_id=obj.id,
+                    detail=f'{date_field} of {date_value} is not in the right date format',
+                    field=self.__config.dates,
+                )
+                return
+
+            # Check if dates are in ascending order
+            if previous_date is not None and date_value < previous_date:
+                self.add_error(
+                    object_id=obj.id,
+                    detail=f'Date {date_field} ({date_value})'
+                    f'is before previous date ({previous_date})',
+                    field=self.__config.dates,
+                )
+                return
+
+            previous_date = date_value

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/validators/ena_checklist.py

@@ -12,6 +12,11 @@ from tol.sources.ena import ena
 
 
 class EnaChecklistValidator(Validator):
+    ENA_TO_INTERNAL_FIELD_MAP = {
+        'geographic location (longitude)': 'DECIMAL_LONGITUDE',
+        'geographic location (latitude)': 'DECIMAL_LATITUDE',
+    }
+
     """
     validates the ENA_CHECKLIST for each samples
     """
@@ -37,16 +42,18 @@ class EnaChecklistValidator(Validator):
             field_name = key
             if 'field' in validation:
                 field_name = validation['field']
+            internal_field = self.ENA_TO_INTERNAL_FIELD_MAP.get(field_name, field_name)
+
             if 'mandatory' in validation and key not in obj.attributes:
-                self.add_error(object_id=obj.id, detail='Must be given', field=[field_name])
+                self.add_error(object_id=obj.id, detail='Must be given', field=[internal_field])
                 continue
             if 'mandatory' in validation and obj.attributes[key] is None:
-                self.add_error(object_id=obj.id, detail='Must be given', field=[field_name])
+                self.add_error(object_id=obj.id, detail='Must be given', field=[internal_field])
                 continue
             if 'mandatory' in validation and obj.attributes.get(key) == '':
                 self.add_error(
                     object_id=obj.id,
-                    detail='Must not be empty', field=[field_name]
+                    detail='Must not be empty', field=[internal_field]
                 )
 
             if 'restricted text' in validation and key in obj.attributes:
@@ -55,12 +62,25 @@ class EnaChecklistValidator(Validator):
                         regex = condition
                 compiled_re = re.compile(regex)
                 if not compiled_re.search(obj.attributes.get(key)):
-                    self.add_error(
-                        object_id=obj.id,
-                        detail='Must match specific pattern', field=[field_name]
-                    )
+                    if internal_field in ('DECIMAL_LONGITUDE', 'DECIMAL_LATITUDE'):
+                        self.add_error(
+                            object_id=obj.id,
+                            detail=(
+                                f'Value for {internal_field} must be a valid decimal in the'
+                                f' format required by ENA (e.g. 12.3456). '
+                                f'See ENA checklist for accepted format.',
+                            ),
+                            field=[internal_field]
+                        )
+                    else:
+                        self.add_error(
+                            object_id=obj.id,
+                            detail=(
+                                f'Value for {internal_field} must match the required pattern.'
+                            ),
+                            field=[internal_field]
+                        )
 
-            # Check against allowed values
             if 'text choice' in validation and key in obj.attributes:
                 for condition in validation:
                     if isinstance(condition, list):
@@ -69,5 +89,5 @@ class EnaChecklistValidator(Validator):
                         [x.lower() for x in allowed_values]:
                     self.add_error(
                         object_id=obj.id,
-                        detail='Must be in allowed values', field=[field_name]
+                        detail='Must be in allowed values', field=[internal_field]
                     )

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/validators/specimens_have_same_taxon.py

@@ -53,7 +53,7 @@ class SpecimensHaveSameTaxonValidator(Validator):
             if specimen_id in self.__seen and taxon_id != self.__seen[specimen_id]:
                 self.add_error(
                     object_id=obj.id,
-                    detail='A non-symbiont must have a matching Specimen ID and Taxon ID',
+                    detail='All samples from the same specimen_ID must have the same TAXON_ID.',
                     field=self.__config.specimen_id_field,
                 )
             if specimen_id not in self.__seen:

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/validators/types.py

@@ -55,12 +55,19 @@ class TypesValidator(Validator):
                     continue
                 type_class = type_map.get(expected_type)
                 if type_class and not isinstance(actual_value, type_class):
-                    self.__add_result(
-                        obj,
-                        key,
-                        detail=f'Field {key} value "{actual_value}" is not of type '
-                               f'"{expected_type}"',
-                    )
+                    if expected_type == 'time':
+                        self.__add_result(
+                            obj,
+                            key,
+                            detail='Only HH:MM format is accepted.',
+                        )
+                    else:
+                        self.__add_result(
+                            obj,
+                            key,
+                            detail=f'Field {key} value "{actual_value}" is not of type '
+                                   f'"{expected_type}"',
+                        )
                 if type_class and isinstance(actual_value, type_class):
                     # Special case for bool since isinstance(True, int) is True
                     if expected_type == 'int' and isinstance(actual_value, bool):

{tol_sdk-1.8.3 → tol_sdk-1.8.5}/src/tol/validators/value_check.py

@@ -26,11 +26,12 @@ class ValueCheckValidator(Validator):
         self.__config = config
 
     def _validate_data_object(self, obj: DataObject) -> None:
-        # This function is used to check if the data object is SYMBIONT or not
-
-        if obj.attributes.get(self.__config.field) == self.__config.value:
+        if obj.attributes.get(self.__config.field) != self.__config.value:
             self.add_error(
                 object_id=obj.id,
-                detail=f'{self.__config.value} is detected',
+                detail=(
+                    f"Expected '{self.__config.value}' for field "
+                    f"'{self.__config.field}', but got '{obj.attributes.get(self.__config.field)}'"
+                ),
                 field=self.__config.field,
             )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tol-sdk
-Version: 1.8.3
+Version: 1.8.5
 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.3 → tol_sdk-1.8.5}/src/tol_sdk.egg-info/SOURCES.txt

@@ -203,6 +203,7 @@ src/tol/flows/converters/sts_sample_project_to_elastic_sample_converter.py
 src/tol/flows/converters/sts_sample_to_casm_benchling_converter.py
 src/tol/flows/converters/sts_sampleset_to_elastic_sampleset_converter.py
 src/tol/flows/converters/sts_species_to_elastic_species_converter.py
+src/tol/flows/converters/time_string_to_time.py
 src/tol/flows/converters/tolid_specimen_to_elastic_tolid_converter.py
 src/tol/flows/converters/tolqc_data_to_elastic_run_data_converter.py
 src/tol/flows/converters/tolqc_sample_to_elastic_sequencing_request_converter.py
@@ -333,7 +334,9 @@ src/tol/validators/allowed_keys.py
 src/tol/validators/allowed_values.py
 src/tol/validators/allowed_values_from_datasource.py
 src/tol/validators/assert_on_condition.py
+src/tol/validators/branching.py
 src/tol/validators/converter_and_validate.py
+src/tol/validators/date_sorting.py
 src/tol/validators/ena_checklist.py
 src/tol/validators/ena_submittable.py
 src/tol/validators/min_one_valid_value.py