JSONSchema¶

Contained within this file are experimental interfaces for working with the Synapse Python Client. Unless otherwise noted these interfaces are subject to change at any time. Use at your own risk.

API Reference¶

synapseclient.models.JSONSchema `dataclass` ¶

Bases: JSONSchemaProtocol

Represents a JSON Schema

ATTRIBUTE	DESCRIPTION
`name`	The name of the schema TYPE: `Optional[str]`
`organization_name`	The name of the organization the schema belongs to TYPE: `Optional[str]`
`organization_id`	the id of the organization the schema belongs to TYPE: `Optional[int]`
`id`	The ID of the schema TYPE: `Optional[str]`
`created_on`	The date this schema was created TYPE: `Optional[str]`
`created_by`	The ID of the user that created this schema TYPE: `Optional[str]`
`uri`	The schema identifier in format: - TYPE: `Optional[str]`

Source code in synapseclient/models/schema_organization.py

@dataclass()
@async_to_sync
class JSONSchema(JSONSchemaProtocol):
    """
    Represents a [JSON Schema](https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/schema/JsonSchemaInfo.html)

    Attributes:
        name: The name of the schema
        organization_name: The name of the organization the schema belongs to
        organization_id: the id of the organization the schema belongs to
        id: The ID of the schema
        created_on: The date this schema was created
        created_by: The ID of the user that created this schema
        uri: The schema identifier in format: <organization_name>-<schema_name>
    """

    name: Optional[str] = None
    """The name of the schema"""

    organization_name: Optional[str] = None
    """The name of the organization the schema belongs to"""

    organization_id: Optional[int] = None
    """The id of the organization the schema belongs to"""

    id: Optional[str] = None
    """The ID of the schema"""

    created_on: Optional[str] = None
    """The date this schema was created"""

    created_by: Optional[str] = None
    """The ID of the user that created this schema"""

    uri: Optional[str] = field(init=False)
    """The schema identifier in format: <organization_name>-<schema_name>"""

    def __post_init__(self) -> None:
        if self.name:
            _check_name(self.name)
        if self.organization_name:
            _check_name(self.organization_name)
        if self.name and self.organization_name:
            self.uri = f"{self.organization_name}-{self.name}"
        else:
            self.uri = None

    async def get_async(
        self, *, synapse_client: Optional["Synapse"] = None
    ) -> "JSONSchema":
        """
        Gets the metadata for this JSONSchema from Synapse

        Arguments:
            synapse_client: If not passed in and caching was not disabled by
                `Synapse.allow_client_caching(False)` this will use the last created
                instance from the Synapse class constructor

        Raises:
            ValueError: This JSONSchema doesn't have a name
            ValueError: This JSONSchema doesn't have an organization name
            ValueError: This JSONSchema doesn't exist in its organization

        Returns:
            Itself

        Example: Get an existing JSONSchema
            &nbsp;

            ```python
            from synapseclient.models import JSONSchema
            from synapseclient import Synapse
            import asyncio

            async def get_schema():

                syn = Synapse()
                syn.login()

                schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
                await schema.get_async()
                return schema

            schema = asyncio.run(get_schema())
            print(schema.uri)
            ```
        """
        if not self.name:
            raise ValueError("JSONSchema must have a name")
        if not self.organization_name:
            raise ValueError("JSONSchema must have a organization_name")

        # Check that the org exists,
        #  if it doesn't list_json_schemas will unhelpfully return an empty generator.
        org = SchemaOrganization(self.organization_name)
        await org.get_async(synapse_client=synapse_client)

        org_schemas = list_json_schemas(
            self.organization_name, synapse_client=synapse_client
        )
        async for schema in org_schemas:
            if schema["schemaName"] == self.name:
                self.fill_from_dict(schema)
                return self
        raise ValueError(
            (
                f"Organization: '{self.organization_name}' does not contain a schema with "
                f"name: '{self.name}'"
            )
        )

    async def store_async(
        self,
        schema_body: dict[str, Any],
        version: Optional[str] = None,
        dry_run: bool = False,
        *,
        synapse_client: Optional["Synapse"] = None,
    ) -> "JSONSchema":
        """
        Stores this JSONSchema in Synapse

        Arguments:
            schema_body: The body of the JSONSchema to store
            version: The version of the JSONSchema body to store
            dry_run: Whether or not to do a dry-run
            synapse_client: If not passed in and caching was not disabled by
                `Synapse.allow_client_caching(False)` this will use the last created
                instance from the Synapse class constructor

        Returns:
            Itself

        Example: Store a JSON Schema in Synapse
            &nbsp;

            ```python
            from synapseclient.models import JSONSchema
            from synapseclient import Synapse
            import asyncio

            async def store_schema():

                syn = Synapse()
                syn.login()

                schema = JSONSchema(organization_name="my.org", name="test.schema")
                schema_body = {
                    {
                        "properties": {
                            "Component": {
                                "description": "TBD",
                                "not": {
                                    "type": "null"
                                },
                                "title": "Component"
                            }
                        }
                    }
                }
                await schema.store_async(schema_body = schema_body)

            asyncio.run(store_schema())
            ```
        """
        if not self.name:
            raise ValueError("JSONSchema must have a name")
        if not self.organization_name:
            raise ValueError("JSONSchema must have a organization_name")

        client = Synapse.get_client(synapse_client=synapse_client)

        request = CreateSchemaRequest(
            schema=schema_body,
            name=self.name,
            organization_name=self.organization_name,
            version=version,
            dry_run=dry_run,
            synapse_schema_url=f"{client.repoEndpoint}/schema/type/registered/",
        )
        completed_request: CreateSchemaRequest = await request.send_job_and_wait_async(
            synapse_client=synapse_client
        )
        new_version_info = completed_request.new_version_info
        self.organization_id = new_version_info.organization_id
        self.created_by = new_version_info.created_by
        self.created_on = new_version_info.created_on
        return self

    async def delete_async(
        self,
        version: Optional[str] = None,
        *,
        synapse_client: Optional["Synapse"] = None,
    ) -> None:
        """
        If a version is supplied the specific version is deleted from Synapse.
        Otherwise the entire schema is deleted from Synapse

        Arguments:
            version: Defaults to None.
            - If a version is supplied, that version will be deleted.
            - If no version is supplied the whole schema will be deleted.
            synapse_client: If not passed in and caching was not disabled by
                `Synapse.allow_client_caching(False)` this will use the last created
                instance from the Synapse class constructor

        Example: Delete an existing JSONSchema

            Delete the whole schema

            ```python
            from synapseclient.models import JSONSchema
            from synapseclient import Synapse
            import asyncio

            async def delete_schema():

                syn = Synapse()
                syn.login()

                schema = JSONSchema(organization_name="my.org", name="test.schema")
                await schema.delete_async()

            asyncio.run(delete_schema())
            ```

            Delete a specific version of the schema

            ```python
            from synapseclient.models import JSONSchema
            from synapseclient import Synapse
            import asyncio

            async def delete_schema():

                syn = Synapse()
                syn.login()

                schema = JSONSchema(organization_name="my.org", name="test.schema")
                await schema.delete_async(version = "0.0.1")

            asyncio.run(delete_schema())
            ```
        """
        if not self.name:
            raise ValueError("JSONSchema must have a name")
        if not self.organization_name:
            raise ValueError("JSONSchema must have a organization_name")

        uri = self.uri
        if version:
            self._check_semantic_version(version)
            uri = f"{uri}-{version}"

        await delete_json_schema(uri, synapse_client=synapse_client)

    @skip_async_to_sync
    async def get_versions_async(
        self, *, synapse_client: Optional["Synapse"] = None
    ) -> AsyncGenerator[JSONSchemaVersionInfo, None]:
        """
        Gets all versions of this JSONSchema

        Arguments:
            synapse_client: If not passed in and caching was not disabled by
                `Synapse.allow_client_caching(False)` this will use the last created
                instance from the Synapse class constructor

        Returns:
            A generator containing each version of this schema

        Example: Get all the versions of the JSONSchema
            &nbsp;

            ```python
            from synapseclient.models import JSONSchema
            from synapseclient import Synapse
            import asyncio

            async def get_versions():

                syn = Synapse()
                syn.login()

                schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
                version_generator = schema.get_versions_async()
                async for item in version_generator:
                    print(item)

            asyncio.run(get_versions())
            ```
        """
        all_schemas = list_json_schema_versions(
            self.organization_name, self.name, synapse_client=synapse_client
        )
        async for schema in all_schemas:
            # Schema "versions" without a semantic version will be returned from the API call,
            # but will be filtered out by this method.
            # Only those with a semantic version will be returned.
            if "semanticVersion" in schema:
                yield self._create_json_schema_version_from_response(schema)

    async def get_body_async(
        self,
        version: Optional[str] = None,
        *,
        synapse_client: Optional["Synapse"] = None,
    ) -> dict[str, Any]:
        """
        Gets the body of this JSONSchema

        Arguments:
            version: Defaults to None.
            - If a version is supplied, that versions body will be returned.
            - If no version is supplied the most recent version will be returned.
            synapse_client: If not passed in and caching was not disabled by
                `Synapse.allow_client_caching(False)` this will use the last created
                instance from the Synapse class constructor

        Returns:
            The JSON Schema body

        Example: Get the body of the JSONSchema

            Get latest version

            ```python
            from synapseclient.models import JSONSchema
            from synapseclient import Synapse
            import asyncio

            async def get_body():

                syn = Synapse()
                syn.login()

                schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
                body = await schema.get_body_async()
                return body

            body = asyncio.run(get_body())
            print(body)
            ```

            Get specific version

            ```python
            from synapseclient.models import JSONSchema
            from synapseclient import Synapse
            import asyncio

            async def get_body():

                syn = Synapse()
                syn.login()

                schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
                body = await schema.get_body_async(version="0.0.1")
                return body

            body = asyncio.run(get_body())
            print(body)
            ```

        """
        if not self.name:
            raise ValueError("JSONSchema must have a name")
        if not self.organization_name:
            raise ValueError("JSONSchema must have a organization_name")

        uri = self.uri
        if version:
            self._check_semantic_version(version)
            uri = f"{uri}-{version}"
        response = await get_json_schema_body(uri, synapse_client=synapse_client)
        return response

    def fill_from_dict(self, response: dict[str, Any]) -> "JSONSchema":
        """
        Fills in this classes attributes using a Synapse API response

        Arguments:
            response: This Synapse API object:
              [JsonSchema](https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/schema/JsonSchema.html)

        Returns:
            Itself
        """
        self.organization_id = response.get("organizationId")
        self.organization_name = response.get("organizationName")
        self.id = response.get("schemaId")
        self.name = response.get("schemaName")
        self.created_on = response.get("createdOn")
        self.created_by = response.get("createdBy")
        self.uri = f"{self.organization_name}-{self.name}"
        return self

    @classmethod
    def from_uri(cls, uri: str) -> "JSONSchema":
        """
        Creates a JSONSchema from a URI.
        The URI can either be a semantic version or not
        - non-semantic: ORGANIZATION.NAME-SCHEMA.NAME
        - semantic: ORGANIZATION.NAME-SCHEMA.NAME-MAJOR.MINOR.PATCH

        Arguments:
            uri: The URI to the JSON Schema in Synapse

        Raises:
            ValueError:  If the URI isn't in the correct form.

        Returns:
            A JSONSchema object

        Example: Create a JSONSchema from a URI
            &nbsp;

            ```python
            from synapseclient.models import JSONSchema

            # Non-semantic URI
            js1 = JSONSchema.from_uri("my.org-my.schema")

            # Semantic URI
            js2 = JSONSchema.from_uri("my.org-my.schema-0.0.1")
            ```

        """
        uri_parts = uri.split("-")
        if len(uri_parts) > 3 or len(uri_parts) < 2:
            msg = (
                "The URI must be in the form of "
                "'<ORGANIZATION>-<NAME>' or '<ORGANIZATION>-<NAME>-<VERSION>': "
                f"{uri}"
            )
            raise ValueError(msg)
        return JSONSchema(name=uri_parts[1], organization_name=uri_parts[0])

    @staticmethod
    def _create_json_schema_version_from_response(
        response: dict[str, Any]
    ) -> JSONSchemaVersionInfo:
        """
        Creates a JSONSchemaVersionInfo object from a Synapse API response

        Arguments:
            response: This Synapse API object:
                [JsonSchemaVersionInfo](https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/schema/JsonSchemaVersionInfo.html)

        Returns:
            A JSONSchemaVersionInfo object
        """
        return JSONSchemaVersionInfo(
            organization_id=response.get("organizationId"),
            organization_name=response.get("organizationName"),
            schema_id=response.get("schemaId"),
            id=response.get("$id"),
            schema_name=response.get("schemaName"),
            version_id=response.get("versionId"),
            semantic_version=response.get("semanticVersion"),
            json_sha256_hex=response.get("jsonSHA256Hex"),
            created_on=response.get("createdOn"),
            created_by=response.get("createdBy"),
        )

    def _check_semantic_version(self, version: str) -> None:
        """
        Checks that the semantic version is correctly formatted

        Arguments:
            version: A semantic version(ie. `1.0.0`) to be checked

        Raises:
            ValueError: If the string is not a correct semantic version
        """
        if version == "0.0.0":
            raise ValueError("Schema version must start at '0.0.1' or higher")
        if not re.match(r"^(\d+)\.(\d+)\.(\d+)$", version):
            raise ValueError(
                (
                    "Schema version must be a semantic version with no letters "
                    "and a major, minor and patch version, such as 0.0.1: "
                    f"{version}"
                )
            )

Functions¶

get_async `async` ¶

get_async(*, synapse_client: Optional[Synapse] = None) -> JSONSchema

Gets the metadata for this JSONSchema from Synapse

PARAMETER	DESCRIPTION
`synapse_client`	If not passed in and caching was not disabled by `Synapse.allow_client_caching(False)` this will use the last created instance from the Synapse class constructor TYPE: `Optional[Synapse]` DEFAULT: `None`

RAISES	DESCRIPTION
`ValueError`	This JSONSchema doesn't have a name
`ValueError`	This JSONSchema doesn't have an organization name
`ValueError`	This JSONSchema doesn't exist in its organization

RETURNS	DESCRIPTION
`JSONSchema`	Itself

Get an existing JSONSchema

from synapseclient.models import JSONSchema
from synapseclient import Synapse
import asyncio

async def get_schema():

    syn = Synapse()
    syn.login()

    schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
    await schema.get_async()
    return schema

schema = asyncio.run(get_schema())
print(schema.uri)

Source code in synapseclient/models/schema_organization.py

async def get_async(
    self, *, synapse_client: Optional["Synapse"] = None
) -> "JSONSchema":
    """
    Gets the metadata for this JSONSchema from Synapse

    Arguments:
        synapse_client: If not passed in and caching was not disabled by
            `Synapse.allow_client_caching(False)` this will use the last created
            instance from the Synapse class constructor

    Raises:
        ValueError: This JSONSchema doesn't have a name
        ValueError: This JSONSchema doesn't have an organization name
        ValueError: This JSONSchema doesn't exist in its organization

    Returns:
        Itself

    Example: Get an existing JSONSchema
        &nbsp;

        ```python
        from synapseclient.models import JSONSchema
        from synapseclient import Synapse
        import asyncio

        async def get_schema():

            syn = Synapse()
            syn.login()

            schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
            await schema.get_async()
            return schema

        schema = asyncio.run(get_schema())
        print(schema.uri)
        ```
    """
    if not self.name:
        raise ValueError("JSONSchema must have a name")
    if not self.organization_name:
        raise ValueError("JSONSchema must have a organization_name")

    # Check that the org exists,
    #  if it doesn't list_json_schemas will unhelpfully return an empty generator.
    org = SchemaOrganization(self.organization_name)
    await org.get_async(synapse_client=synapse_client)

    org_schemas = list_json_schemas(
        self.organization_name, synapse_client=synapse_client
    )
    async for schema in org_schemas:
        if schema["schemaName"] == self.name:
            self.fill_from_dict(schema)
            return self
    raise ValueError(
        (
            f"Organization: '{self.organization_name}' does not contain a schema with "
            f"name: '{self.name}'"
        )
    )

store_async `async` ¶

store_async(schema_body: dict[str, Any], version: Optional[str] = None, dry_run: bool = False, *, synapse_client: Optional[Synapse] = None) -> JSONSchema

Stores this JSONSchema in Synapse

PARAMETER	DESCRIPTION
`schema_body`	The body of the JSONSchema to store TYPE: `dict[str, Any]`
`version`	The version of the JSONSchema body to store TYPE: `Optional[str]` DEFAULT: `None`
`dry_run`	Whether or not to do a dry-run TYPE: `bool` DEFAULT: `False`
`synapse_client`	If not passed in and caching was not disabled by `Synapse.allow_client_caching(False)` this will use the last created instance from the Synapse class constructor TYPE: `Optional[Synapse]` DEFAULT: `None`

RETURNS	DESCRIPTION
`JSONSchema`	Itself

Store a JSON Schema in Synapse

from synapseclient.models import JSONSchema
from synapseclient import Synapse
import asyncio

async def store_schema():

    syn = Synapse()
    syn.login()

    schema = JSONSchema(organization_name="my.org", name="test.schema")
    schema_body = {
        {
            "properties": {
                "Component": {
                    "description": "TBD",
                    "not": {
                        "type": "null"
                    },
                    "title": "Component"
                }
            }
        }
    }
    await schema.store_async(schema_body = schema_body)

asyncio.run(store_schema())

Source code in synapseclient/models/schema_organization.py

async def store_async(
    self,
    schema_body: dict[str, Any],
    version: Optional[str] = None,
    dry_run: bool = False,
    *,
    synapse_client: Optional["Synapse"] = None,
) -> "JSONSchema":
    """
    Stores this JSONSchema in Synapse

    Arguments:
        schema_body: The body of the JSONSchema to store
        version: The version of the JSONSchema body to store
        dry_run: Whether or not to do a dry-run
        synapse_client: If not passed in and caching was not disabled by
            `Synapse.allow_client_caching(False)` this will use the last created
            instance from the Synapse class constructor

    Returns:
        Itself

    Example: Store a JSON Schema in Synapse
        &nbsp;

        ```python
        from synapseclient.models import JSONSchema
        from synapseclient import Synapse
        import asyncio

        async def store_schema():

            syn = Synapse()
            syn.login()

            schema = JSONSchema(organization_name="my.org", name="test.schema")
            schema_body = {
                {
                    "properties": {
                        "Component": {
                            "description": "TBD",
                            "not": {
                                "type": "null"
                            },
                            "title": "Component"
                        }
                    }
                }
            }
            await schema.store_async(schema_body = schema_body)

        asyncio.run(store_schema())
        ```
    """
    if not self.name:
        raise ValueError("JSONSchema must have a name")
    if not self.organization_name:
        raise ValueError("JSONSchema must have a organization_name")

    client = Synapse.get_client(synapse_client=synapse_client)

    request = CreateSchemaRequest(
        schema=schema_body,
        name=self.name,
        organization_name=self.organization_name,
        version=version,
        dry_run=dry_run,
        synapse_schema_url=f"{client.repoEndpoint}/schema/type/registered/",
    )
    completed_request: CreateSchemaRequest = await request.send_job_and_wait_async(
        synapse_client=synapse_client
    )
    new_version_info = completed_request.new_version_info
    self.organization_id = new_version_info.organization_id
    self.created_by = new_version_info.created_by
    self.created_on = new_version_info.created_on
    return self

delete_async `async` ¶

delete_async(version: Optional[str] = None, *, synapse_client: Optional[Synapse] = None) -> None

If a version is supplied the specific version is deleted from Synapse. Otherwise the entire schema is deleted from Synapse

PARAMETER	DESCRIPTION
`version`	Defaults to None. TYPE: `Optional[str]` DEFAULT: `None`
`synapse_client`	If not passed in and caching was not disabled by `Synapse.allow_client_caching(False)` this will use the last created instance from the Synapse class constructor TYPE: `Optional[Synapse]` DEFAULT: `None`

Example: Delete an existing JSONSchema

Delete the whole schema

```python
from synapseclient.models import JSONSchema
from synapseclient import Synapse
import asyncio

async def delete_schema():

    syn = Synapse()
    syn.login()

    schema = JSONSchema(organization_name="my.org", name="test.schema")
    await schema.delete_async()

asyncio.run(delete_schema())
```

Delete a specific version of the schema

```python
from synapseclient.models import JSONSchema
from synapseclient import Synapse
import asyncio

async def delete_schema():

    syn = Synapse()
    syn.login()

    schema = JSONSchema(organization_name="my.org", name="test.schema")
    await schema.delete_async(version = "0.0.1")

asyncio.run(delete_schema())
```

Source code in synapseclient/models/schema_organization.py

async def delete_async(
    self,
    version: Optional[str] = None,
    *,
    synapse_client: Optional["Synapse"] = None,
) -> None:
    """
    If a version is supplied the specific version is deleted from Synapse.
    Otherwise the entire schema is deleted from Synapse

    Arguments:
        version: Defaults to None.
        - If a version is supplied, that version will be deleted.
        - If no version is supplied the whole schema will be deleted.
        synapse_client: If not passed in and caching was not disabled by
            `Synapse.allow_client_caching(False)` this will use the last created
            instance from the Synapse class constructor

    Example: Delete an existing JSONSchema

        Delete the whole schema

        ```python
        from synapseclient.models import JSONSchema
        from synapseclient import Synapse
        import asyncio

        async def delete_schema():

            syn = Synapse()
            syn.login()

            schema = JSONSchema(organization_name="my.org", name="test.schema")
            await schema.delete_async()

        asyncio.run(delete_schema())
        ```

        Delete a specific version of the schema

        ```python
        from synapseclient.models import JSONSchema
        from synapseclient import Synapse
        import asyncio

        async def delete_schema():

            syn = Synapse()
            syn.login()

            schema = JSONSchema(organization_name="my.org", name="test.schema")
            await schema.delete_async(version = "0.0.1")

        asyncio.run(delete_schema())
        ```
    """
    if not self.name:
        raise ValueError("JSONSchema must have a name")
    if not self.organization_name:
        raise ValueError("JSONSchema must have a organization_name")

    uri = self.uri
    if version:
        self._check_semantic_version(version)
        uri = f"{uri}-{version}"

    await delete_json_schema(uri, synapse_client=synapse_client)

get_versions_async `async` ¶

get_versions_async(*, synapse_client: Optional[Synapse] = None) -> AsyncGenerator[JSONSchemaVersionInfo, None]

Gets all versions of this JSONSchema

PARAMETER	DESCRIPTION
`synapse_client`	If not passed in and caching was not disabled by `Synapse.allow_client_caching(False)` this will use the last created instance from the Synapse class constructor TYPE: `Optional[Synapse]` DEFAULT: `None`

RETURNS	DESCRIPTION
`AsyncGenerator[JSONSchemaVersionInfo, None]`	A generator containing each version of this schema

Get all the versions of the JSONSchema

from synapseclient.models import JSONSchema
from synapseclient import Synapse
import asyncio

async def get_versions():

    syn = Synapse()
    syn.login()

    schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
    version_generator = schema.get_versions_async()
    async for item in version_generator:
        print(item)

asyncio.run(get_versions())

Source code in synapseclient/models/schema_organization.py

@skip_async_to_sync
async def get_versions_async(
    self, *, synapse_client: Optional["Synapse"] = None
) -> AsyncGenerator[JSONSchemaVersionInfo, None]:
    """
    Gets all versions of this JSONSchema

    Arguments:
        synapse_client: If not passed in and caching was not disabled by
            `Synapse.allow_client_caching(False)` this will use the last created
            instance from the Synapse class constructor

    Returns:
        A generator containing each version of this schema

    Example: Get all the versions of the JSONSchema
        &nbsp;

        ```python
        from synapseclient.models import JSONSchema
        from synapseclient import Synapse
        import asyncio

        async def get_versions():

            syn = Synapse()
            syn.login()

            schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
            version_generator = schema.get_versions_async()
            async for item in version_generator:
                print(item)

        asyncio.run(get_versions())
        ```
    """
    all_schemas = list_json_schema_versions(
        self.organization_name, self.name, synapse_client=synapse_client
    )
    async for schema in all_schemas:
        # Schema "versions" without a semantic version will be returned from the API call,
        # but will be filtered out by this method.
        # Only those with a semantic version will be returned.
        if "semanticVersion" in schema:
            yield self._create_json_schema_version_from_response(schema)

get_body_async `async` ¶

get_body_async(version: Optional[str] = None, *, synapse_client: Optional[Synapse] = None) -> dict[str, Any]

Gets the body of this JSONSchema

PARAMETER	DESCRIPTION
`version`	Defaults to None. TYPE: `Optional[str]` DEFAULT: `None`
`synapse_client`	If not passed in and caching was not disabled by `Synapse.allow_client_caching(False)` this will use the last created instance from the Synapse class constructor TYPE: `Optional[Synapse]` DEFAULT: `None`

RETURNS	DESCRIPTION
`dict[str, Any]`	The JSON Schema body

Example: Get the body of the JSONSchema

Get latest version

```python
from synapseclient.models import JSONSchema
from synapseclient import Synapse
import asyncio

async def get_body():

    syn = Synapse()
    syn.login()

    schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
    body = await schema.get_body_async()
    return body

body = asyncio.run(get_body())
print(body)
```

Get specific version

```python
from synapseclient.models import JSONSchema
from synapseclient import Synapse
import asyncio

async def get_body():

    syn = Synapse()
    syn.login()

    schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
    body = await schema.get_body_async(version="0.0.1")
    return body

body = asyncio.run(get_body())
print(body)
```

Source code in synapseclient/models/schema_organization.py

async def get_body_async(
    self,
    version: Optional[str] = None,
    *,
    synapse_client: Optional["Synapse"] = None,
) -> dict[str, Any]:
    """
    Gets the body of this JSONSchema

    Arguments:
        version: Defaults to None.
        - If a version is supplied, that versions body will be returned.
        - If no version is supplied the most recent version will be returned.
        synapse_client: If not passed in and caching was not disabled by
            `Synapse.allow_client_caching(False)` this will use the last created
            instance from the Synapse class constructor

    Returns:
        The JSON Schema body

    Example: Get the body of the JSONSchema

        Get latest version

        ```python
        from synapseclient.models import JSONSchema
        from synapseclient import Synapse
        import asyncio

        async def get_body():

            syn = Synapse()
            syn.login()

            schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
            body = await schema.get_body_async()
            return body

        body = asyncio.run(get_body())
        print(body)
        ```

        Get specific version

        ```python
        from synapseclient.models import JSONSchema
        from synapseclient import Synapse
        import asyncio

        async def get_body():

            syn = Synapse()
            syn.login()

            schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
            body = await schema.get_body_async(version="0.0.1")
            return body

        body = asyncio.run(get_body())
        print(body)
        ```

    """
    if not self.name:
        raise ValueError("JSONSchema must have a name")
    if not self.organization_name:
        raise ValueError("JSONSchema must have a organization_name")

    uri = self.uri
    if version:
        self._check_semantic_version(version)
        uri = f"{uri}-{version}"
    response = await get_json_schema_body(uri, synapse_client=synapse_client)
    return response

from_uri `classmethod` ¶

from_uri(uri: str) -> JSONSchema

Creates a JSONSchema from a URI. The URI can either be a semantic version or not - non-semantic: ORGANIZATION.NAME-SCHEMA.NAME - semantic: ORGANIZATION.NAME-SCHEMA.NAME-MAJOR.MINOR.PATCH

PARAMETER	DESCRIPTION
`uri`	The URI to the JSON Schema in Synapse TYPE: `str`

RAISES	DESCRIPTION
`ValueError`	If the URI isn't in the correct form.

RETURNS	DESCRIPTION
`JSONSchema`	A JSONSchema object

Create a JSONSchema from a URI

from synapseclient.models import JSONSchema

# Non-semantic URI
js1 = JSONSchema.from_uri("my.org-my.schema")

# Semantic URI
js2 = JSONSchema.from_uri("my.org-my.schema-0.0.1")

Source code in synapseclient/models/schema_organization.py

@classmethod
def from_uri(cls, uri: str) -> "JSONSchema":
    """
    Creates a JSONSchema from a URI.
    The URI can either be a semantic version or not
    - non-semantic: ORGANIZATION.NAME-SCHEMA.NAME
    - semantic: ORGANIZATION.NAME-SCHEMA.NAME-MAJOR.MINOR.PATCH

    Arguments:
        uri: The URI to the JSON Schema in Synapse

    Raises:
        ValueError:  If the URI isn't in the correct form.

    Returns:
        A JSONSchema object

    Example: Create a JSONSchema from a URI
        &nbsp;

        ```python
        from synapseclient.models import JSONSchema

        # Non-semantic URI
        js1 = JSONSchema.from_uri("my.org-my.schema")

        # Semantic URI
        js2 = JSONSchema.from_uri("my.org-my.schema-0.0.1")
        ```

    """
    uri_parts = uri.split("-")
    if len(uri_parts) > 3 or len(uri_parts) < 2:
        msg = (
            "The URI must be in the form of "
            "'<ORGANIZATION>-<NAME>' or '<ORGANIZATION>-<NAME>-<VERSION>': "
            f"{uri}"
        )
        raise ValueError(msg)
    return JSONSchema(name=uri_parts[1], organization_name=uri_parts[0])

JSONSchema¶

API Reference¶

synapseclient.models.JSONSchema dataclass ¶

Functions¶

get_async async ¶

store_async async ¶

delete_async async ¶

get_versions_async async ¶

get_body_async async ¶

from_uri classmethod ¶

synapseclient.models.JSONSchema `dataclass` ¶

get_async `async` ¶

store_async `async` ¶

delete_async `async` ¶

get_versions_async `async` ¶

get_body_async `async` ¶

from_uri `classmethod` ¶