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
             

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

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

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

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

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

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

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

get(*, 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

Get an existing SchemaOrganization

 

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse

syn = Synapse()
syn.login()

org = SchemaOrganization("dpetest")
org.get()
print(org)

Source code in synapseclient/models/schema_organization.py

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

    Example: Get an existing SchemaOrganization
         

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

        syn = Synapse()
        syn.login()

        org = SchemaOrganization("dpetest")
        org.get()
        print(org)
        ```

    """
    return self

store

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

Store the SchemaOrganization in Synapse

 

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse

syn = Synapse()
syn.login()

org = SchemaOrganization("my.org.name")
org.store()
print(org)

Source code in synapseclient/models/schema_organization.py

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

    Example: Store the SchemaOrganization in Synapse
         

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

        syn = Synapse()
        syn.login()

        org = SchemaOrganization("my.org.name")
        org.store()
        print(org)
        ```

    """
    return self

delete

delete(*, 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 the SchemaOrganization from Synapse

 

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse

syn = Synapse()
syn.login()

org = SchemaOrganization("my.org.name")
org.delete()

Source code in synapseclient/models/schema_organization.py

def delete(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 the SchemaOrganization from Synapse
         

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

        syn = Synapse()
        syn.login()

        org = SchemaOrganization("my.org.name")
        org.delete()
        ```
    """
    return None

get_json_schemas

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

Gets the JSON Schemas that are part of 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: A Generator containing the JSONSchemas that belong to this organization

Get the JSONSchemas that are part of this SchemaOrganization

 

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse

syn = Synapse()
syn.login()

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

Source code in synapseclient/models/schema_organization.py

def get_json_schemas(
    self, *, synapse_client: Optional["Synapse"] = None
) -> Generator["JSONSchema", None, None]:
    """
    Gets the JSON Schemas that are part of 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 Generator containing the JSONSchemas that belong to this organization

    Example: Get the JSONSchemas that are part of this SchemaOrganization
         

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

        syn = Synapse()
        syn.login()

        org = SchemaOrganization("dpetest")
        js_generator = org.get_json_schemas()
        for item in js_generator:
            print(item)
        ```
    """
    yield from wrap_async_generator_to_sync_generator(
        async_gen_func=self.get_json_schemas_async,
        synapse_client=synapse_client,
    )

get_acl

get_acl(*, 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 the SchemaOrganization

 

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse

syn = Synapse()
syn.login()

org = SchemaOrganization("my.org.name")
org.get_acl()

Source code in synapseclient/models/schema_organization.py

def get_acl(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 the SchemaOrganization
         

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

        syn = Synapse()
        syn.login()

        org = SchemaOrganization("my.org.name")
        org.get_acl()
        ```
    """
    return {}

update_acl

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

Update the ACL for the SchemaOrganization

 

from synapseclient.models import SchemaOrganization
from synapseclient import Synapse

syn = Synapse()
syn.login()

org = SchemaOrganization("my.org.name")
org.update_acl(
    principal_id=1,
    access_type=["READ"]
)

Source code in synapseclient/models/schema_organization.py

def update_acl(
    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 the SchemaOrganization
         

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

        syn = Synapse()
        syn.login()

        org = SchemaOrganization("my.org.name")
        org.update_acl(
            principal_id=1,
            access_type=["READ"]
        )
        ```
    """
    return None