SchemaOrganization¶

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.SchemaOrganization `dataclass` ¶

Bases: SchemaOrganizationProtocol

Represents an Organization.

ATTRIBUTE	DESCRIPTION
`name`	The name of the organization TYPE: `Optional[str]`
`id`	The ID of the organization TYPE: `Optional[str]`
`created_on`	The date this organization was created TYPE: `Optional[str]`
`created_by`	The ID of the user that created this organization TYPE: `Optional[str]`

Source code in synapseclient/models/schema_organization.py

@dataclass()
@async_to_sync
class SchemaOrganization(SchemaOrganizationProtocol):
    """
    Represents an [Organization](https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/schema/Organization.html).

    Attributes:
        name: The name of the organization
        id: The ID of the organization
        created_on: The date this organization was created
        created_by: The ID of the user that created this organization
    """

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

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

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

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

    def __post_init__(self) -> None:
        if self.name:
            _check_name(self.name)

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

        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: If the name has not been set

        Example: Get an existing SchemaOrganization
            &nbsp;

            ```python

            from synapseclient.models import SchemaOrganization
            from synapseclient import Synapse
            import asyncio

            async def get_org():

                syn = Synapse()
                syn.login()

                org = SchemaOrganization("dpetest")
                await org.get_async()
                return org

            org = asyncio.run(get_org())
            print(org.name)
            print(org.id)
            ```
        """
        if not self.name:
            raise ValueError("SchemaOrganization must have a name")
        response = await get_organization(self.name, synapse_client=synapse_client)
        self.fill_from_dict(response)
        return self

    async def store_async(
        self, *, synapse_client: Optional["Synapse"] = None
    ) -> "SchemaOrganization":
        """
        Stores this organization in 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

        Returns:
            Itself

        Raises:
            ValueError: If the name has not been set

        Example: Store a new SchemaOrganization
            &nbsp;

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

            async def store_org():

                syn = Synapse()
                syn.login()

                org = SchemaOrganization("my.new.org")
                await org.store_async()
                return org

            org = asyncio.run(store_org())
            print(org.name)
            print(org.id)
            ```
        """
        if not self.name:
            raise ValueError("SchemaOrganization must have a name")
        response = await create_organization(self.name, synapse_client=synapse_client)
        self.fill_from_dict(response)
        return self

    async def delete_async(self, *, synapse_client: Optional["Synapse"] = None) -> None:
        """
        Deletes this organization in 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

        Example: Delete a SchemaOrganization using a name
            &nbsp;

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

            async def delete_org():

                syn = Synapse()
                syn.login()

                org = SchemaOrganization("my.org")
                await org.delete_async()

            asyncio.run(delete_org())
            ```

        Example: Delete a SchemaOrganization using an id
            &nbsp;

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

            async def delete_org():

                syn = Synapse()
                syn.login()

                org = SchemaOrganization(id=1075)
                await org.delete_async()

            asyncio.run(delete_org())
            ```
        """
        if not self.id:
            await self.get_async(synapse_client=synapse_client)
        await delete_organization(
            organization_id=self.id, synapse_client=synapse_client
        )

    @skip_async_to_sync
    async def get_json_schemas_async(
        self, *, synapse_client: Optional["Synapse"] = None
    ) -> AsyncGenerator["JSONSchema", None]:
        """
        Gets the JSONSchemas that are part of this organization

        Returns: An AsyncGenerator of JSONSchemas

        Raises:
            ValueError: If the name has not been set

        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

        Example: Get a list of JSONSchemas that belong to the SchemaOrganization
            &nbsp;

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

            async def get_schemas():

                syn = Synapse()
                syn.login()

                org = SchemaOrganization("dpetest")
                js_generator = org.get_json_schemas_async()
                async for item in js_generator:
                    print(item)

            asyncio.run(get_schemas())
            ```

        """
        if not self.name:
            raise ValueError("SchemaOrganization must have a name")
        response = list_json_schemas(self.name, synapse_client=synapse_client)
        async for item in response:
            yield JSONSchema().fill_from_dict(item)

    async def get_acl_async(
        self, *, synapse_client: Optional["Synapse"] = None
    ) -> dict[str, Any]:
        """
        Gets the ACL for this organization

        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 dictionary in the form of this response:
              [AccessControlList]https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/AccessControlList.html

        Example: Get the ACL for a SchemaOrganization
            &nbsp;

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

            async def get_acl():

                syn = Synapse()
                syn.login()

                org = SchemaOrganization("dpetest")
                acl = await org.get_acl_async()
                return acl

            acl = asyncio.run(get_acl())
            etag = acl["etag"]
            print(etag)
            resource_access = acl["resourceAccess"]
            for item in resource_access:
                principal_id = item["principalId"]
                print((principal_id))
                access_types = item["accessType"]
                print(access_types)
            ```
        """
        if not self.id:
            await self.get_async(synapse_client=synapse_client)
        response = await get_organization_acl(self.id, synapse_client=synapse_client)
        return response

    async def update_acl_async(
        self,
        principal_id: int,
        access_type: list[str],
        *,
        synapse_client: Optional["Synapse"] = None,
    ) -> None:
        """
        Updates the ACL for a principal for this organization

        Arguments:
            principal_id: the id of the principal whose permissions are to be updated
            access_type: List of permission types (e.g., ["READ", "CREATE", "DELETE"])
                see:
                  [ACCESS_TYPE]https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/ACCESS_TYPE.html
            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: Update the ACL for a SchemaOrganization
            &nbsp;

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

            async def update_acl() -> None:

                syn = Synapse()
                syn.login()

                org = SchemaOrganization("dpetest")
                await org.update_acl_async(
                    principal_id=1,
                    access_type=["READ"]
                )

            asyncio.run(update_acl())

        """
        acl = await self.get_acl_async(synapse_client=synapse_client)

        resource_access: list[dict[str, Any]] = acl["resourceAccess"]
        etag = acl["etag"]

        principal_id_match = False
        for permissions in resource_access:
            if permissions["principalId"] == principal_id:
                permissions["accessType"] = access_type
                principal_id_match = True

        if not principal_id_match:
            resource_access.append(
                {"principalId": principal_id, "accessType": access_type}
            )

        await update_organization_acl(
            organization_id=self.id,
            resource_access=resource_access,
            etag=etag,
            synapse_client=synapse_client,
        )

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

        Args:
            response: A response from this endpoint:
              [Organization]https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/schema/Organization.html

        Returns:
            Itself
        """
        self.name = response.get("name")
        self.id = response.get("id")
        self.created_on = response.get("createdOn")
        self.created_by = response.get("createdBy")
        return self

Functions¶

get_async `async` ¶

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

Gets the metadata from Synapse for this organization

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

RAISES	DESCRIPTION
`ValueError`	If the name has not been set

Get an existing SchemaOrganization

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse
import asyncio

async def get_org():

    syn = Synapse()
    syn.login()

    org = SchemaOrganization("dpetest")
    await org.get_async()
    return org

org = asyncio.run(get_org())
print(org.name)
print(org.id)

Source code in synapseclient/models/schema_organization.py

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

    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: If the name has not been set

    Example: Get an existing SchemaOrganization
        &nbsp;

        ```python

        from synapseclient.models import SchemaOrganization
        from synapseclient import Synapse
        import asyncio

        async def get_org():

            syn = Synapse()
            syn.login()

            org = SchemaOrganization("dpetest")
            await org.get_async()
            return org

        org = asyncio.run(get_org())
        print(org.name)
        print(org.id)
        ```
    """
    if not self.name:
        raise ValueError("SchemaOrganization must have a name")
    response = await get_organization(self.name, synapse_client=synapse_client)
    self.fill_from_dict(response)
    return self

store_async `async` ¶

store_async(*, synapse_client: Optional[Synapse] = None) -> SchemaOrganization

Stores this organization in 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`

RETURNS	DESCRIPTION
`SchemaOrganization`	Itself

RAISES	DESCRIPTION
`ValueError`	If the name has not been set

Store a new SchemaOrganization

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse
import asyncio

async def store_org():

    syn = Synapse()
    syn.login()

    org = SchemaOrganization("my.new.org")
    await org.store_async()
    return org

org = asyncio.run(store_org())
print(org.name)
print(org.id)

Source code in synapseclient/models/schema_organization.py

async def store_async(
    self, *, synapse_client: Optional["Synapse"] = None
) -> "SchemaOrganization":
    """
    Stores this organization in 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

    Returns:
        Itself

    Raises:
        ValueError: If the name has not been set

    Example: Store a new SchemaOrganization
        &nbsp;

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

        async def store_org():

            syn = Synapse()
            syn.login()

            org = SchemaOrganization("my.new.org")
            await org.store_async()
            return org

        org = asyncio.run(store_org())
        print(org.name)
        print(org.id)
        ```
    """
    if not self.name:
        raise ValueError("SchemaOrganization must have a name")
    response = await create_organization(self.name, synapse_client=synapse_client)
    self.fill_from_dict(response)
    return self

delete_async `async` ¶

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

Deletes this organization in 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`

Delete a SchemaOrganization using a name

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse
import asyncio

async def delete_org():

    syn = Synapse()
    syn.login()

    org = SchemaOrganization("my.org")
    await org.delete_async()

asyncio.run(delete_org())

Delete a SchemaOrganization using an id

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse
import asyncio

async def delete_org():

    syn = Synapse()
    syn.login()

    org = SchemaOrganization(id=1075)
    await org.delete_async()

asyncio.run(delete_org())

Source code in synapseclient/models/schema_organization.py

async def delete_async(self, *, synapse_client: Optional["Synapse"] = None) -> None:
    """
    Deletes this organization in 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

    Example: Delete a SchemaOrganization using a name
        &nbsp;

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

        async def delete_org():

            syn = Synapse()
            syn.login()

            org = SchemaOrganization("my.org")
            await org.delete_async()

        asyncio.run(delete_org())
        ```

    Example: Delete a SchemaOrganization using an id
        &nbsp;

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

        async def delete_org():

            syn = Synapse()
            syn.login()

            org = SchemaOrganization(id=1075)
            await org.delete_async()

        asyncio.run(delete_org())
        ```
    """
    if not self.id:
        await self.get_async(synapse_client=synapse_client)
    await delete_organization(
        organization_id=self.id, synapse_client=synapse_client
    )

get_json_schemas_async `async` ¶

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

Gets the JSONSchemas that are part of this organization

Returns: An AsyncGenerator of JSONSchemas

RAISES	DESCRIPTION
`ValueError`	If the name has not been set

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`

Get a list of JSONSchemas that belong to the SchemaOrganization

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse
import asyncio

async def get_schemas():

    syn = Synapse()
    syn.login()

    org = SchemaOrganization("dpetest")
    js_generator = org.get_json_schemas_async()
    async for item in js_generator:
        print(item)

asyncio.run(get_schemas())

Source code in synapseclient/models/schema_organization.py

@skip_async_to_sync
async def get_json_schemas_async(
    self, *, synapse_client: Optional["Synapse"] = None
) -> AsyncGenerator["JSONSchema", None]:
    """
    Gets the JSONSchemas that are part of this organization

    Returns: An AsyncGenerator of JSONSchemas

    Raises:
        ValueError: If the name has not been set

    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

    Example: Get a list of JSONSchemas that belong to the SchemaOrganization
        &nbsp;

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

        async def get_schemas():

            syn = Synapse()
            syn.login()

            org = SchemaOrganization("dpetest")
            js_generator = org.get_json_schemas_async()
            async for item in js_generator:
                print(item)

        asyncio.run(get_schemas())
        ```

    """
    if not self.name:
        raise ValueError("SchemaOrganization must have a name")
    response = list_json_schemas(self.name, synapse_client=synapse_client)
    async for item in response:
        yield JSONSchema().fill_from_dict(item)

get_acl_async `async` ¶

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

Gets the ACL for this organization

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
`dict[str, Any]`	A dictionary in the form of this response: [AccessControlList]https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/AccessControlList.html

Get the ACL for a SchemaOrganization

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse
import asyncio

async def get_acl():

    syn = Synapse()
    syn.login()

    org = SchemaOrganization("dpetest")
    acl = await org.get_acl_async()
    return acl

acl = asyncio.run(get_acl())
etag = acl["etag"]
print(etag)
resource_access = acl["resourceAccess"]
for item in resource_access:
    principal_id = item["principalId"]
    print((principal_id))
    access_types = item["accessType"]
    print(access_types)

Source code in synapseclient/models/schema_organization.py

async def get_acl_async(
    self, *, synapse_client: Optional["Synapse"] = None
) -> dict[str, Any]:
    """
    Gets the ACL for this organization

    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 dictionary in the form of this response:
          [AccessControlList]https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/AccessControlList.html

    Example: Get the ACL for a SchemaOrganization
        &nbsp;

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

        async def get_acl():

            syn = Synapse()
            syn.login()

            org = SchemaOrganization("dpetest")
            acl = await org.get_acl_async()
            return acl

        acl = asyncio.run(get_acl())
        etag = acl["etag"]
        print(etag)
        resource_access = acl["resourceAccess"]
        for item in resource_access:
            principal_id = item["principalId"]
            print((principal_id))
            access_types = item["accessType"]
            print(access_types)
        ```
    """
    if not self.id:
        await self.get_async(synapse_client=synapse_client)
    response = await get_organization_acl(self.id, synapse_client=synapse_client)
    return response

update_acl_async `async` ¶

update_acl_async(principal_id: int, access_type: list[str], *, synapse_client: Optional[Synapse] = None) -> None

Updates the ACL for a principal for this organization

PARAMETER	DESCRIPTION
`principal_id`	the id of the principal whose permissions are to be updated TYPE: `int`
`access_type`	List of permission types (e.g., ["READ", "CREATE", "DELETE"]) see: [ACCESS_TYPE]https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/ACCESS_TYPE.html TYPE: `list[str]`
`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`	Update the ACL for a SchemaOrganization
`async def update_acl() -> None`	syn = Synapse() syn.login() org = SchemaOrganization("dpetest") await org.update_acl_async( principal_id=1, access_type=["READ"] )

Source code in synapseclient/models/schema_organization.py

async def update_acl_async(
    self,
    principal_id: int,
    access_type: list[str],
    *,
    synapse_client: Optional["Synapse"] = None,
) -> None:
    """
    Updates the ACL for a principal for this organization

    Arguments:
        principal_id: the id of the principal whose permissions are to be updated
        access_type: List of permission types (e.g., ["READ", "CREATE", "DELETE"])
            see:
              [ACCESS_TYPE]https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/ACCESS_TYPE.html
        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: Update the ACL for a SchemaOrganization
        &nbsp;

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

        async def update_acl() -> None:

            syn = Synapse()
            syn.login()

            org = SchemaOrganization("dpetest")
            await org.update_acl_async(
                principal_id=1,
                access_type=["READ"]
            )

        asyncio.run(update_acl())

    """
    acl = await self.get_acl_async(synapse_client=synapse_client)

    resource_access: list[dict[str, Any]] = acl["resourceAccess"]
    etag = acl["etag"]

    principal_id_match = False
    for permissions in resource_access:
        if permissions["principalId"] == principal_id:
            permissions["accessType"] = access_type
            principal_id_match = True

    if not principal_id_match:
        resource_access.append(
            {"principalId": principal_id, "accessType": access_type}
        )

    await update_organization_acl(
        organization_id=self.id,
        resource_access=resource_access,
        etag=etag,
        synapse_client=synapse_client,
    )

SchemaOrganization¶

API Reference¶

synapseclient.models.SchemaOrganization dataclass ¶

Functions¶

get_async async ¶

store_async async ¶

delete_async async ¶

get_json_schemas_async async ¶

get_acl_async async ¶

update_acl_async async ¶

synapseclient.models.SchemaOrganization `dataclass` ¶

get_async `async` ¶

store_async `async` ¶

delete_async `async` ¶

get_json_schemas_async `async` ¶

get_acl_async `async` ¶

update_acl_async `async` ¶