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 ¶

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

Gets this JSONSchemas metadata

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
`JSONSchema`	Itself

RAISES	DESCRIPTION
`ValueError`	This JSONSchema doesn't exist in its organization

Get an Existing JSONSchema

from synapseclient.models import JSONSchema
from synapseclient import Synapse

syn = Synapse()
syn.login()

js = JSONSchema("my.schema.name", "my.org.name")
js.get()
print(js)

Source code in synapseclient/models/schema_organization.py

def get(self, *, synapse_client: Optional["Synapse"] = None) -> "JSONSchema":
    """
    Gets this JSONSchemas metadata

    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:
        Itself

    Raises:
        ValueError: This JSONSchema doesn't exist in its organization

    Example: Get an Existing JSONSchema
        &nbsp;

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

        syn = Synapse()
        syn.login()

        js = JSONSchema("my.schema.name", "my.org.name")
        js.get()
        print(js)
        ```
    """
    return self

store ¶

store(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

syn = Synapse()
syn.login()

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

Source code in synapseclient/models/schema_organization.py

def store(
    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

        syn = Synapse()
        syn.login()

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

delete ¶

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

Deletes 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`

Example: Delete from Synapse

Delete the entire schema

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

syn = Synapse()
syn.login()

js = JSONSchema("my.schema.name", "my.org.name")
js.delete()
```

Delete a specific version from Synapse

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

syn = Synapse()
syn.login()

js = JSONSchema("my.schema.name", "my.org.name")
js.delete(version="0.0.1")
```

Source code in synapseclient/models/schema_organization.py

def delete(
    self,
    version: Optional[str] = None,
    *,
    synapse_client: Optional["Synapse"] = None,
) -> None:
    """
    Deletes this JSONSchema

    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 from Synapse

        Delete the entire schema

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

        syn = Synapse()
        syn.login()

        js = JSONSchema("my.schema.name", "my.org.name")
        js.delete()
        ```

        Delete a specific version from Synapse

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

        syn = Synapse()
        syn.login()

        js = JSONSchema("my.schema.name", "my.org.name")
        js.delete(version="0.0.1")
        ```
    """
    return None

get_versions ¶

get_versions(*, synapse_client: Optional[Synapse] = None) -> Generator[JSONSchemaVersionInfo, None, 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
`None`	A Generator containing the JSONSchemaVersionInfo for each version of this schema

Get all versions of the JSONSchema

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

syn = Synapse() syn.login()

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

Source code in synapseclient/models/schema_organization.py

def get_versions(
    self, *, synapse_client: Optional["Synapse"] = None
) -> Generator["JSONSchemaVersionInfo", None, 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 the JSONSchemaVersionInfo for each version of this schema

    Example: Get all versions of the JSONSchema
        &nbsp;

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

        syn = Synapse()
        syn.login()

        schema = JSONSchema(organization_name="dpetest", name="test.schematic.Biospecimen")
        version_generator = schema.get_versions()
        for item in version_generator:
            print(item)
    """
    yield from wrap_async_generator_to_sync_generator(
        async_gen_func=self.get_versions_async,
        synapse_client=synapse_client,
    )

get_body ¶

get_body(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

Get the JSONSchema body from Synapse

from synapseclient.models import JSONSchema
from synapseclient import Synapse

syn = Synapse()
syn.login()

js = JSONSchema("my.schema.name", "my.org.name")
# Get latest version
latest = js.get_body()
print(latest)
# Get specific version
first = js.get_body("0.0.1")
print(first)

Source code in synapseclient/models/schema_organization.py

def get_body(
    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 JSONSchema body from Synapse
        &nbsp;

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

        syn = Synapse()
        syn.login()

        js = JSONSchema("my.schema.name", "my.org.name")
        # Get latest version
        latest = js.get_body()
        print(latest)
        # Get specific version
        first = js.get_body("0.0.1")
        print(first)
        ```
    """
    return {}

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 ¶

store ¶

delete ¶

get_versions ¶

get_body ¶

from_uri classmethod ¶

synapseclient.models.JSONSchema `dataclass` ¶

from_uri `classmethod` ¶