manually create get_invalid_validation; remove changes to async_to_sync; add a way to skip async_to_sync for generator

Author: linglp

synapseclient/api/json_schema_services.py

@@ -147,6 +147,17 @@ async def get_invalid_json_schema_validation(
         yield item
 
 
+def get_invalid_json_schema_validation_sync(
+    synapse_id: str, *, synapse_client: Optional["Synapse"] = None
+):
+    request_body = {"containerId": synapse_id}
+    response = synapse_client._POST_paginated(
+        f"/entity/{synapse_id}/schema/validation/invalid", request_body
+    )
+    for item in response:
+        yield item
+
+
 async def get_json_schema_derived_keys(
     synapse_id: str, *, synapse_client: Optional["Synapse"] = None
 ) -> "JSONSchemaDerivedKeys":

synapseclient/core/async_utils.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import functools
-import inspect
 from typing import TYPE_CHECKING, Any, Callable, Coroutine, Union
 
 import nest_asyncio
@@ -114,16 +113,7 @@ def newmethod(self, *args, **kwargs):
 
             async def wrapper(*args, **kwargs):
                 """Wrapper for the function to be called in an async context."""
-                result = getattr(self, async_method_name)(*args, **kwargs)
-                if inspect.isasyncgen(result):
-                    # collect all values into a list
-                    return [item async for item in result]
-                elif inspect.iscoroutine(result):
-                    return await result
-                else:
-                    raise TypeError(
-                        f"Expected an async generator or coroutine, got {type(result)}"
-                    )
+                return await getattr(self, async_method_name)(*args, **kwargs)
 
             loop = None
 
@@ -144,9 +134,11 @@ async def wrapper(*args, **kwargs):
 
     methods_to_update = []
     for k in methods:
+        if getattr(cls.__dict__[k], "_skip_conversion", False):
+            continue
+
         if "async" in k and (new_method_name := k.replace("_async", "")):
             new_method = create_method(k)
-
             new_method.fn.__name__ = new_method_name
             new_method.__name__ = new_method_name
 
@@ -163,3 +155,8 @@ async def wrapper(*args, **kwargs):
         )
 
     return cls
+
+
+def skip_async_to_sync(func):
+    func._skip_conversion = True
+    return func

synapseclient/models/mixins/json_schema.py

@@ -1,16 +1,17 @@
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, AsyncGenerator, List, Optional, Union
+from typing import TYPE_CHECKING, AsyncGenerator, Generator, List, Optional, Union
 
 from synapseclient.api.json_schema_services import (
     bind_json_schema_to_entity,
     delete_json_schema_from_entity,
     get_invalid_json_schema_validation,
+    get_invalid_json_schema_validation_sync,
     get_json_schema_derived_keys,
     get_json_schema_from_entity,
     get_json_schema_validation_statistics,
     validate_entity_with_json_schema,
 )
-from synapseclient.core.async_utils import async_to_sync
+from synapseclient.core.async_utils import async_to_sync, skip_async_to_sync
 from synapseclient.models.protocols.json_schema_protocol import (
     BaseJSONSchemaProtocol,
     ContainerEntityJSONSchemaProtocol,
@@ -412,9 +413,10 @@ async def get_schema_validation_statistics_async(
             number_of_unknown_children=response.get("numberOfUnknownChildren", None),
         )
 
+    @skip_async_to_sync
     async def get_invalid_validation_async(
         self, *, synapse_client: Optional["Synapse"] = None
-    ) -> AsyncGenerator[InvalidJSONSchemaValidation, None]:
+    ) -> AsyncGenerator[InvalidJSONSchemaValidation, None, None]:
         """
         Get invalid JSON schema validation results for a container entity.
 
@@ -473,3 +475,66 @@ async def get_invalid_validation_async(
                     ],
                 ),
             )
+
+    def get_invalid_validation(
+        self, *, synapse_client: Optional["Synapse"] = None
+    ) -> Generator[InvalidJSONSchemaValidation, None, None]:
+        """
+        Get invalid JSON schema validation results for a container entity.
+
+        Arguments:
+            synapse_client (Optional[Synapse], optional): The Synapse client instance. If not provided,
+                the last created instance from the Synapse class constructor will be used.
+
+        Yields:
+            InvalidJSONSchemaValidation: An object containing the validation response, all validation messages,
+                                         and the validation exception details.
+        """
+        gen = get_invalid_json_schema_validation_sync(
+            synapse_client=synapse_client, synapse_id=self.id
+        )
+
+        for item in gen:
+            yield InvalidJSONSchemaValidation(
+                validation_response=JSONSchemaValidation(
+                    object_id=item.get("objectId", None),
+                    object_type=item.get("objectType", None),
+                    object_etag=item.get("objectEtag", None),
+                    id=item.get("schema$id", None),
+                    is_valid=item.get("isValid", None),
+                    validated_on=item.get("validatedOn", None),
+                ),
+                validation_error_message=item.get("validationErrorMessage", None),
+                all_validation_messages=item.get("allValidationMessages", []),
+                validation_exception=ValidationException(
+                    pointer_to_violation=item.get("validationException", {}).get(
+                        "pointerToViolation", None
+                    ),
+                    message=item.get("validationException", {}).get("message", None),
+                    schema_location=item.get("validationException", {}).get(
+                        "schemaLocation", None
+                    ),
+                    causing_exceptions=[
+                        CausingException(
+                            keyword=ce.get("keyword", None),
+                            pointer_to_violation=ce.get("pointerToViolation", None),
+                            message=ce.get("message", None),
+                            schema_location=ce.get("schemaLocation", None),
+                            causing_exceptions=[
+                                CausingException(
+                                    keyword=nce.get("keyword", None),
+                                    pointer_to_violation=nce.get(
+                                        "pointerToViolation", None
+                                    ),
+                                    message=nce.get("message", None),
+                                    schema_location=nce.get("schemaLocation", None),
+                                )
+                                for nce in ce.get("causingExceptions", [])
+                            ],
+                        )
+                        for ce in item.get("validationException", {}).get(
+                            "causingExceptions", []
+                        )
+                    ],
+                ),
+            )