From e0fdb912f047946692c71dfe8c5af9b56c7637d9 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Mon, 9 Feb 2026 15:34:58 -0500
Subject: [PATCH 01/31] Add schema management wrapper functions using OOP
 models

- Create schema_management.py with register_jsonschema and bind_jsonschema
- Export functions from curator extension __init__.py
---
 synapseclient/extensions/curator/__init__.py  |   3 +
 .../extensions/curator/schema_management.py   | 159 ++++++++++++++++++
 2 files changed, 162 insertions(+)
 create mode 100644 synapseclient/extensions/curator/schema_management.py

diff --git a/synapseclient/extensions/curator/__init__.py b/synapseclient/extensions/curator/__init__.py
index 78aa25456..8bbf22529 100644
--- a/synapseclient/extensions/curator/__init__.py
+++ b/synapseclient/extensions/curator/__init__.py
@@ -7,6 +7,7 @@
 from .file_based_metadata_task import create_file_based_metadata_task
 from .record_based_metadata_task import create_record_based_metadata_task
 from .schema_generation import generate_jsonld, generate_jsonschema
+from .schema_management import bind_jsonschema, register_jsonschema
 from .schema_registry import query_schema_registry
 
 __all__ = [
@@ -15,4 +16,6 @@
     "query_schema_registry",
     "generate_jsonld",
     "generate_jsonschema",
+    "register_jsonschema",
+    "bind_jsonschema",
 ]
diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
new file mode 100644
index 000000000..ea0d50d13
--- /dev/null
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -0,0 +1,159 @@
+"""
+Wrapper functions for JSON Schema registration and binding operations.
+
+This module provides convenience functions for CLI commands that interact with
+the Synapse JSON Schema OOP models.
+"""
+
+import json
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from synapseclient import Synapse
+
+
+def register_jsonschema(
+    schema_path: str,
+    organization_name: str,
+    schema_name: str,
+    schema_version: Optional[str] = None,
+    synapse_client: Optional["Synapse"] = None,
+) -> tuple[str, str]:
+    """
+    Register a JSON schema to a Synapse organization.
+
+    This function loads a JSON schema from a file and registers it with a specified
+    organization in Synapse using the JSONSchema OOP model.
+
+    Arguments:
+        schema_path: Path to the JSON schema file to register
+        organization_name: Name of the organization to register the schema under
+        schema_name: The name of the JSON schema
+        schema_version: Optional version of the schema (e.g., '0.0.1').
+                       If not specified, a version will be auto-generated.
+        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 tuple of (schema_uri, message) where:
+        - schema_uri is the full URI of the registered schema
+        - message is a success message
+
+    Example: Register a JSON schema
+        ```python
+        from synapseclient import Synapse
+        from synapseclient.extensions.curator import register_jsonschema
+
+        syn = Synapse()
+        syn.login()
+
+        schema_uri, message = register_jsonschema(
+            schema_path="/path/to/schema.json",
+            organization_name="my.org",
+            schema_name="my.schema",
+            schema_version="0.0.1",
+            synapse_client=syn
+        )
+        print(message)
+        print(f"Schema URI: {schema_uri}")
+        ```
+    """
+    from synapseclient.models.schema_organization import JSONSchema
+
+    # Load the schema from file
+    with open(schema_path, "r") as f:
+        schema_body = json.load(f)
+
+    # Create JSONSchema instance
+    json_schema = JSONSchema(name=schema_name, organization_name=organization_name)
+
+    # Store the schema with optional version
+    json_schema.store(
+        schema_body=schema_body,
+        version=schema_version,
+        synapse_client=synapse_client,
+    )
+
+    # Build the schema URI
+    schema_uri = f"{organization_name}-{schema_name}"
+    if schema_version:
+        schema_uri += f"-{schema_version}"
+
+    message = f"Successfully registered schema '{schema_name}' to organization '{organization_name}'"
+
+    return schema_uri, message
+
+
+def bind_jsonschema(
+    entity_id: str,
+    json_schema_uri: str,
+    enable_derived_annotations: bool = False,
+    synapse_client: Optional["Synapse"] = None,
+) -> dict:
+    """
+    Bind a JSON schema to a Synapse entity.
+
+    This function binds a JSON schema to a Synapse entity using the Entity OOP model's
+    bind_schema method.
+
+    Arguments:
+        entity_id: The Synapse ID of the entity to bind the schema to (e.g., syn12345678)
+        json_schema_uri: The URI of the JSON Schema to bind (e.g., 'my.org-schema.name-1.0.0')
+        enable_derived_annotations: If true, enable derived annotations. Defaults to 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
+
+    Returns:
+        A dictionary containing the binding details
+
+    Example: Bind a JSON schema to an entity
+        ```python
+        from synapseclient import Synapse
+        from synapseclient.extensions.curator import bind_jsonschema
+
+        syn = Synapse()
+        syn.login()
+
+        result = bind_jsonschema(
+            entity_id="syn12345678",
+            json_schema_uri="my.org-my.schema-0.0.1",
+            enable_derived_annotations=True,
+            synapse_client=syn
+        )
+        print(f"Successfully bound schema: {result}")
+        ```
+    """
+    from synapseclient import Synapse
+
+    syn = Synapse.get_client(synapse_client=synapse_client)
+
+    # Get the entity to determine its type and use its bind_schema method
+    entity = syn.get(entity_id, downloadFile=False)
+
+    # Use the entity's bind_schema method if available (new OOP models)
+    if hasattr(entity, "bind_schema"):
+        result = entity.bind_schema(
+            json_schema_uri=json_schema_uri,
+            enable_derived_annotations=enable_derived_annotations,
+            synapse_client=syn,
+        )
+    else:
+        # Fallback to direct API call for old-style entities
+        from synapseclient.api.json_schema_services import bind_json_schema_to_entity
+        import asyncio
+
+        result = asyncio.run(
+            bind_json_schema_to_entity(
+                synapse_id=entity_id,
+                json_schema_uri=json_schema_uri,
+                enable_derived_annotations=enable_derived_annotations,
+                synapse_client=syn,
+            )
+        )
+
+    # Convert result to dictionary format for consistent return type
+    if hasattr(result, "__dict__"):
+        return vars(result)
+    return result

From c8fb80fcdaf9a6b8a27a28e987deb2e113c2670a Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Mon, 9 Feb 2026 15:35:21 -0500
Subject: [PATCH 02/31] Update CLI commands to use OOP model wrapper functions

- Update register_json_schema to use register_jsonschema wrapper
- Update bind_json_schema to use bind_jsonschema wrapper
- Add register-json-schema CLI command with argparse configuration
---
 synapseclient/__main__.py | 79 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)

diff --git a/synapseclient/__main__.py b/synapseclient/__main__.py
index 50b12b82f..acc0d489d 100644
--- a/synapseclient/__main__.py
+++ b/synapseclient/__main__.py
@@ -36,6 +36,10 @@
     SynapseNoCredentialsError,
 )
 from synapseclient.extensions.curator.schema_generation import generate_jsonschema
+from synapseclient.extensions.curator.schema_management import (
+    bind_jsonschema,
+    register_jsonschema,
+)
 from synapseclient.wiki import Wiki
 
 tracer = trace.get_tracer("synapseclient")
@@ -814,6 +818,33 @@ def generate_json_schema(args, syn):
     logging.info(f"Created JSON Schema files: [{paths}]")
 
 
+def register_json_schema(args, syn):
+    """Register a JSON schema to a Synapse organization."""
+    schema_uri, message = register_jsonschema(
+        schema_path=args.schema_path,
+        organization_name=args.organization_name,
+        schema_name=args.schema_name,
+        schema_version=args.schema_version,
+        synapse_client=syn,
+    )
+    syn.logger.info(message)
+    syn.logger.info(f"Schema URI: {schema_uri}")
+
+
+def bind_json_schema(args, syn):
+    """Bind a JSON schema to a Synapse entity."""
+    result = bind_jsonschema(
+        entity_id=args.id,
+        json_schema_uri=args.json_schema_uri,
+        enable_derived_annotations=args.enable_derived_annotations,
+        synapse_client=syn,
+    )
+    syn.logger.info(
+        f"Successfully bound schema '{args.json_schema_uri}' to entity '{args.id}'"
+    )
+    syn.logger.info(f"Binding details: {result}")
+
+
 def build_parser():
     """Builds the argument parser and returns the result."""
 
@@ -1845,6 +1876,54 @@ def build_parser():
     )
     parser_generate_json_schema.set_defaults(func=generate_json_schema)
 
+    parser_register_json_schema = subparsers.add_parser(
+        "register-json-schema", help="Register a JSON Schema to a Synapse organization."
+    )
+    parser_register_json_schema.add_argument(
+        "schema_path",
+        type=str,
+        help="Path to the JSON schema file to register",
+    )
+    parser_register_json_schema.add_argument(
+        "organization_name",
+        type=str,
+        help="Name of the organization to register the schema under",
+    )
+    parser_register_json_schema.add_argument(
+        "schema_name",
+        type=str,
+        help="The name of the JSON schema",
+    )
+    parser_register_json_schema.add_argument(
+        "--schema-version",
+        dest="schema_version",
+        type=str,
+        default=None,
+        help="Version of the schema to register (e.g., '0.0.1'). If not specified, a version will be auto-generated.",
+    )
+    parser_register_json_schema.set_defaults(func=register_json_schema)
+
+    parser_bind_json_schema = subparsers.add_parser(
+        "bind-json-schema", help="Bind a JSON Schema to a Synapse entity."
+    )
+    parser_bind_json_schema.add_argument(
+        "id",
+        type=str,
+        help="The Synapse ID of the entity to bind the schema to (e.g., syn12345678).",
+    )
+    parser_bind_json_schema.add_argument(
+        "json_schema_uri",
+        type=str,
+        help="The URI of the JSON Schema to bind (e.g., 'my.org-schema.name-1.0.0').",
+    )
+    parser_bind_json_schema.add_argument(
+        "--enable-derived-annotations",
+        action="store_true",
+        default=False,
+        help="Enable derived annotations to auto-populate annotations from schema. Defaults to False.",
+    )
+    parser_bind_json_schema.set_defaults(func=bind_json_schema)
+
     parser_migrate.set_defaults(func=migrate)
 
     return parser

From 0c5bbd2db759eb0320425cbf25b6ae0facfbb240 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Mon, 9 Feb 2026 15:35:40 -0500
Subject: [PATCH 03/31] Add register-json-schema command to CLI documentation

- Add register-json-schema to table of contents
- Add complete command documentation with usage and parameters
- Document schema registration workflow
---
 docs/tutorials/command_line_client.md | 31 +++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/docs/tutorials/command_line_client.md b/docs/tutorials/command_line_client.md
index 2b7763e7a..8c572df2d 100644
--- a/docs/tutorials/command_line_client.md
+++ b/docs/tutorials/command_line_client.md
@@ -82,6 +82,8 @@ synapse [-h] [--version] [-u SYNAPSEUSER] [-p SYNAPSE_AUTH_TOKEN] [-c CONFIGPATH
 - [get-sts-token](#get-sts-token): Get an STS token for access to AWS S3 storage underlying Synapse
 - [migrate](#migrate): Migrate Synapse entities to a different storage location
 - [generate-json-schema](#generate-json-schema): Generate JSON Schema(s) from a data model
+- [register-json-schema](#register-json-schema): Register a JSON Schema to a Synapse organization
+- [bind-json-schema](#bind-json-schema): Bind a JSON Schema to a Synapse entity
 
 ### `get`
 
@@ -558,3 +560,32 @@ synapse generate-json-schema [-h] [--data-types data_type1, data_type2] [--outpu
 | `--data-types`           | Named      | Optional list of data types to create JSON Schema for               |
 | `--output`               | Named      | Optional. Either a file path ending in '.json', or a directory path |
 | `--data-model-labels`    | Named      | Either 'class_label', or 'display_label'                            |
+
+### `register-json-schema`
+
+Register a JSON Schema to a Synapse organization for later binding to entities.
+
+```bash
+synapse register-json-schema [-h] [--schema-version VERSION] schema_path organization_name schema_name
+```
+
+| Name                  | Type       | Description                                                                         | Default |
+|-----------------------|------------|-------------------------------------------------------------------------------------|---------|
+| `schema_path`         | Positional | Path to the JSON schema file to register                                            |         |
+| `organization_name`   | Positional | Name of the organization to register the schema under                               |         |
+| `schema_name`         | Positional | The name of the JSON schema                                                         |         |
+| `--schema-version`    | Named      | Version of the schema to register (e.g., '0.0.1'). If not specified, auto-generated | None    |
+
+### `bind-json-schema`
+
+Bind a registered JSON Schema to a Synapse entity for metadata validation.
+
+```bash
+synapse bind-json-schema [-h] [--enable-derived-annotations] id json_schema_uri
+```
+
+| Name                          | Type       | Description                                                                        | Default |
+|-------------------------------|------------|------------------------------------------------------------------------------------|---------|
+| `id`                          | Positional | The Synapse ID of the entity to bind the schema to (e.g., syn12345678)             |         |
+| `json_schema_uri`             | Positional | The URI of the JSON Schema to bind (e.g., 'my.org-schema.name-1.0.0')              |         |
+| `--enable-derived-annotations`| Named      | Enable derived annotations to auto-populate annotations from schema                | False   |

From e20b7f99204825b26b1f4b39c7e47a832f0af6d7 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Mon, 9 Feb 2026 15:35:57 -0500
Subject: [PATCH 04/31] Add register and bind examples to Python tutorial

- Update tutorial to cover complete JSON Schema workflow
- Add section 9: Register JSON Schema to Synapse
- Add section 10: Bind JSON Schema to entities
- Update tutorial script with register_jsonschema and bind_jsonschema examples
- Update imports and line references
---
 docs/tutorials/python/schema_operations.md    | 59 +++++++++++++++----
 .../tutorial_scripts/schema_operations.py     | 26 +++++++-
 2 files changed, 74 insertions(+), 11 deletions(-)

diff --git a/docs/tutorials/python/schema_operations.md b/docs/tutorials/python/schema_operations.md
index a8376e316..7586dbd9b 100644
--- a/docs/tutorials/python/schema_operations.md
+++ b/docs/tutorials/python/schema_operations.md
@@ -2,11 +2,16 @@ JSON Schema is a tool used to validate data. In Synapse, JSON Schemas can be use
 
 Synapse supports a subset of features from [json-schema-draft-07](https://json-schema.org/draft-07). To see the list of features currently supported, see the [JSON Schema object definition](https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/schema/JsonSchema.html) from Synapse's REST API Documentation.
 
-In this tutorial, you will learn how to create these JSON Schema using an existing data model.
+In this tutorial, you will learn how to create, register, and bind JSON Schemas using an existing data model.
 
 ## Tutorial Purpose
 
-You will create a JSON schema from your data model using the Python client as a library. To use the CLI tool, see the [documentation](../command_line_client.md).
+You will learn the complete JSON Schema workflow:
+1. **Generate** JSON schemas from your data model
+2. **Register** schemas to a Synapse organization
+3. **Bind** schemas to Synapse entities for metadata validation
+
+This tutorial uses the Python client as a library. To use the CLI tool, see the [command line documentation](../command_line_client.md).
 
 ## Prerequisites
 
@@ -16,13 +21,19 @@ You will create a JSON schema from your data model using the Python client as a
 ## 1. Imports
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=1-2}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=1-6}
 ```
 
+You'll need to import:
+- `Synapse` - for authentication
+- `generate_jsonschema` - to create schemas from data models
+- `register_jsonschema` - to register schemas in Synapse
+- `bind_jsonschema` - to bind schemas to entities
+
 ## 2. Set up your variables
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=4-11}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=8-15}
 ```
 
 To create a JSON Schema you need a data model, and the data types you want to create.
@@ -34,7 +45,7 @@ The data types must exist in your data model. This can be a list of data types,
 ## 3. Log into Synapse
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=13-14}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=17-18}
 ```
 
 ## 4. Create a JSON Schema
@@ -42,7 +53,7 @@ The data types must exist in your data model. This can be a list of data types,
 Create a JSON Schema
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=16-23}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=20-27}
 ```
 
 You should see the first JSON Schema for the datatype you selected printed.
@@ -54,7 +65,7 @@ By setting the `output` parameter as path to a "temp" directory, the file will b
 Create multiple JSON Schema
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=26-32}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=30-36}
 ```
 
 The `data_types` parameter is a list and can have multiple data types.
@@ -64,7 +75,7 @@ The `data_types` parameter is a list and can have multiple data types.
 Create every JSON Schema
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=34-39}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=38-43}
 ```
 
 If you don't set a `data_types` parameter a JSON Schema will be created for every data type in the data model.
@@ -74,7 +85,7 @@ If you don't set a `data_types` parameter a JSON Schema will be created for ever
 Create a JSON Schema
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=41-47}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=45-51}
 ```
 
 If you have only one data type and set the `output` parameter to a file path(ending in.json), the JSON Schema file will have that path.
@@ -84,11 +95,39 @@ If you have only one data type and set the `output` parameter to a file path(end
 Create a JSON Schema
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=49-54}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=53-58}
 ```
 
 If you don't set `output` parameter the JSON Schema file will be created in the current working directory.
 
+## 9. Register a JSON Schema to Synapse
+
+Once you've created a JSON Schema file, you can register it to a Synapse organization.
+
+```python
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=60-69}
+```
+
+The `register_jsonschema` function:
+- Takes a path to your generated JSON Schema file
+- Registers it with the specified organization in Synapse
+- Returns the schema URI and a success message
+- You can optionally specify a version (e.g., "0.0.1") or let it auto-generate
+
+## 10. Bind a JSON Schema to a Synapse Entity
+
+After registering a schema, you can bind it to Synapse entities (files, folders, etc.) for metadata validation.
+
+```python
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=71-78}
+```
+
+The `bind_jsonschema` function:
+- Takes a Synapse entity ID (e.g., "syn12345678")
+- Binds the registered schema URI to that entity
+- Optionally enables derived annotations to auto-populate metadata
+- Returns binding details
+
 ## Source Code for this Tutorial
 
 <details class="quote">
diff --git a/docs/tutorials/python/tutorial_scripts/schema_operations.py b/docs/tutorials/python/tutorial_scripts/schema_operations.py
index 1f244c53a..fda057fa8 100644
--- a/docs/tutorials/python/tutorial_scripts/schema_operations.py
+++ b/docs/tutorials/python/tutorial_scripts/schema_operations.py
@@ -1,5 +1,9 @@
 from synapseclient import Synapse
-from synapseclient.extensions.curator import generate_jsonschema
+from synapseclient.extensions.curator import (
+    bind_jsonschema,
+    generate_jsonschema,
+    register_jsonschema,
+)
 
 # Path or URL to your data model (CSV or JSONLD format)
 # Example: "path/to/my_data_model.csv" or "https://raw.githubusercontent.com/example.csv"
@@ -52,3 +56,23 @@
     data_types=DATA_TYPE,
     synapse_client=syn,
 )
+
+# Register a JSON Schema to Synapse
+schema_uri, message = register_jsonschema(
+    schema_path="temp/Patient.json",  # Path to the generated JSON Schema file
+    organization_name="my.organization",  # Your Synapse organization name
+    schema_name="patient.schema",  # Name for the schema
+    schema_version="0.0.1",  # Optional version number
+    synapse_client=syn,
+)
+print(message)
+print(f"Registered schema URI: {schema_uri}")
+
+# Bind a JSON Schema to a Synapse entity
+result = bind_jsonschema(
+    entity_id="syn12345678",  # Replace with your entity ID (file, folder, etc.)
+    json_schema_uri=schema_uri,  # URI from the registration step above
+    enable_derived_annotations=True,  # Enable auto-population of metadata
+    synapse_client=syn,
+)
+print(f"Successfully bound schema to entity: {result}")

From 42d5b8fdfba83e54d783d7531ab789657c7a4926 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Mon, 9 Feb 2026 15:37:19 -0500
Subject: [PATCH 05/31] [test] Add unit tests for bind-json-schema CLI command

- Add test for argument parsing
- Add test for --enable-derived-annotations flag
- Add test for API call invocation
---
 .../synapseclient/unit_test_commandline.py    | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/tests/unit/synapseclient/unit_test_commandline.py b/tests/unit/synapseclient/unit_test_commandline.py
index 442e5a76a..b887b6abe 100644
--- a/tests/unit/synapseclient/unit_test_commandline.py
+++ b/tests/unit/synapseclient/unit_test_commandline.py
@@ -976,3 +976,58 @@ def test_jsonld_path(self):
         finally:
             if os.path.isfile(schema_path):
                 os.remove(schema_path)
+
+
+class TestBindJSONSchemaFunction:
+    @pytest.fixture(scope="function", autouse=True)
+    @patch("synapseclient.client.Synapse")
+    def setup(self, mock_syn):
+        self.syn = mock_syn
+
+    def test_bind_json_schema_parses_arguments(self):
+        """Test that the parser correctly parses bind-json-schema arguments."""
+        # GIVEN a parser
+        parser = cmdline.build_parser()
+        # WHEN I parse bind-json-schema arguments
+        args = parser.parse_args(
+            ["bind-json-schema", "syn12345678", "my.org-schema.name-1.0.0"]
+        )
+        # THEN the arguments should be parsed correctly
+        assert args.id == "syn12345678"
+        assert args.json_schema_uri == "my.org-schema.name-1.0.0"
+        assert args.enable_derived_annotations is False
+
+    def test_bind_json_schema_with_derived_annotations(self):
+        """Test parsing with --enable-derived-annotations flag."""
+        # GIVEN a parser
+        parser = cmdline.build_parser()
+        # WHEN I parse bind-json-schema arguments with --enable-derived-annotations
+        args = parser.parse_args(
+            [
+                "bind-json-schema",
+                "syn12345678",
+                "my.org-schema.name-1.0.0",
+                "--enable-derived-annotations",
+            ]
+        )
+        # THEN enable_derived_annotations should be True
+        assert args.enable_derived_annotations is True
+
+    @patch("asyncio.run")
+    def test_bind_json_schema_calls_api(self, mock_asyncio_run):
+        """Test that bind_json_schema calls the API correctly."""
+        # GIVEN a mocked API response
+        mock_asyncio_run.return_value = {"entityId": "syn12345678"}
+        parser = cmdline.build_parser()
+        args = parser.parse_args(
+            [
+                "bind-json-schema",
+                "syn12345678",
+                "my.org-schema.name-1.0.0",
+                "--enable-derived-annotations",
+            ]
+        )
+        # WHEN I call bind_json_schema
+        cmdline.bind_json_schema(args, self.syn)
+        # THEN asyncio.run should be called once
+        mock_asyncio_run.assert_called_once()

From ae634daaa8b1496080c038fec4826d67407d0bc0 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Mon, 9 Feb 2026 15:50:55 -0500
Subject: [PATCH 06/31] [test] Fix bind-json-schema test to match new wrapper
 implementation

Update test to mock bind_jsonschema wrapper instead of asyncio.run,
and verify correct arguments are passed to the wrapper function.
---
 .../synapseclient/unit_test_commandline.py    | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/tests/unit/synapseclient/unit_test_commandline.py b/tests/unit/synapseclient/unit_test_commandline.py
index b887b6abe..7f22a85e2 100644
--- a/tests/unit/synapseclient/unit_test_commandline.py
+++ b/tests/unit/synapseclient/unit_test_commandline.py
@@ -1013,11 +1013,11 @@ def test_bind_json_schema_with_derived_annotations(self):
         # THEN enable_derived_annotations should be True
         assert args.enable_derived_annotations is True
 
-    @patch("asyncio.run")
-    def test_bind_json_schema_calls_api(self, mock_asyncio_run):
-        """Test that bind_json_schema calls the API correctly."""
-        # GIVEN a mocked API response
-        mock_asyncio_run.return_value = {"entityId": "syn12345678"}
+    @patch("synapseclient.__main__.bind_jsonschema")
+    def test_bind_json_schema_calls_wrapper(self, mock_bind_jsonschema):
+        """Test that bind_json_schema calls the wrapper function correctly."""
+        # GIVEN a mocked wrapper response
+        mock_bind_jsonschema.return_value = {"entityId": "syn12345678"}
         parser = cmdline.build_parser()
         args = parser.parse_args(
             [
@@ -1029,5 +1029,10 @@ def test_bind_json_schema_calls_api(self, mock_asyncio_run):
         )
         # WHEN I call bind_json_schema
         cmdline.bind_json_schema(args, self.syn)
-        # THEN asyncio.run should be called once
-        mock_asyncio_run.assert_called_once()
+        # THEN bind_jsonschema should be called with correct arguments
+        mock_bind_jsonschema.assert_called_once_with(
+            entity_id="syn12345678",
+            json_schema_uri="my.org-schema.name-1.0.0",
+            enable_derived_annotations=True,
+            synapse_client=self.syn,
+        )

From a8245efd985d0a652bb39334a2245fae2c72767f Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 09:20:56 -0500
Subject: [PATCH 07/31] Use JSONSchema.uri instead of manually building URI

---
 synapseclient/extensions/curator/schema_management.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index ea0d50d13..ce701444d 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -75,10 +75,8 @@ def register_jsonschema(
         synapse_client=synapse_client,
     )
 
-    # Build the schema URI
-    schema_uri = f"{organization_name}-{schema_name}"
-    if schema_version:
-        schema_uri += f"-{schema_version}"
+    # Get the schema URI from the JSONSchema object
+    schema_uri = json_schema.uri
 
     message = f"Successfully registered schema '{schema_name}' to organization '{organization_name}'"
 

From 208eaa6d85131613cfa2e5e4025b30bbda62e021 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 09:24:01 -0500
Subject: [PATCH 08/31] Log success message in register_jsonschema instead of
 returning it

- Update register_jsonschema to log message and return only schema_uri
- Update CLI function to match new signature
- Update docstring and examples
---
 .../tutorial_scripts/schema_operations.py     |  3 +--
 synapseclient/__main__.py                     |  4 +---
 .../extensions/curator/schema_management.py   | 24 +++++++++++--------
 3 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/docs/tutorials/python/tutorial_scripts/schema_operations.py b/docs/tutorials/python/tutorial_scripts/schema_operations.py
index fda057fa8..728f19102 100644
--- a/docs/tutorials/python/tutorial_scripts/schema_operations.py
+++ b/docs/tutorials/python/tutorial_scripts/schema_operations.py
@@ -58,14 +58,13 @@
 )
 
 # Register a JSON Schema to Synapse
-schema_uri, message = register_jsonschema(
+schema_uri = register_jsonschema(
     schema_path="temp/Patient.json",  # Path to the generated JSON Schema file
     organization_name="my.organization",  # Your Synapse organization name
     schema_name="patient.schema",  # Name for the schema
     schema_version="0.0.1",  # Optional version number
     synapse_client=syn,
 )
-print(message)
 print(f"Registered schema URI: {schema_uri}")
 
 # Bind a JSON Schema to a Synapse entity
diff --git a/synapseclient/__main__.py b/synapseclient/__main__.py
index acc0d489d..0cef35e52 100644
--- a/synapseclient/__main__.py
+++ b/synapseclient/__main__.py
@@ -820,15 +820,13 @@ def generate_json_schema(args, syn):
 
 def register_json_schema(args, syn):
     """Register a JSON schema to a Synapse organization."""
-    schema_uri, message = register_jsonschema(
+    register_jsonschema(
         schema_path=args.schema_path,
         organization_name=args.organization_name,
         schema_name=args.schema_name,
         schema_version=args.schema_version,
         synapse_client=syn,
     )
-    syn.logger.info(message)
-    syn.logger.info(f"Schema URI: {schema_uri}")
 
 
 def bind_json_schema(args, syn):
diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index ce701444d..e56aae23d 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -18,7 +18,7 @@ def register_jsonschema(
     schema_name: str,
     schema_version: Optional[str] = None,
     synapse_client: Optional["Synapse"] = None,
-) -> tuple[str, str]:
+) -> str:
     """
     Register a JSON schema to a Synapse organization.
 
@@ -36,9 +36,7 @@ def register_jsonschema(
                        instance from the Synapse class constructor
 
     Returns:
-        A tuple of (schema_uri, message) where:
-        - schema_uri is the full URI of the registered schema
-        - message is a success message
+        The URI of the registered schema
 
     Example: Register a JSON schema
         ```python
@@ -48,19 +46,21 @@ def register_jsonschema(
         syn = Synapse()
         syn.login()
 
-        schema_uri, message = register_jsonschema(
+        schema_uri = register_jsonschema(
             schema_path="/path/to/schema.json",
             organization_name="my.org",
             schema_name="my.schema",
             schema_version="0.0.1",
             synapse_client=syn
         )
-        print(message)
-        print(f"Schema URI: {schema_uri}")
+        print(f"Registered schema URI: {schema_uri}")
         ```
     """
+    from synapseclient import Synapse
     from synapseclient.models.schema_organization import JSONSchema
 
+    syn = Synapse.get_client(synapse_client=synapse_client)
+
     # Load the schema from file
     with open(schema_path, "r") as f:
         schema_body = json.load(f)
@@ -72,15 +72,19 @@ def register_jsonschema(
     json_schema.store(
         schema_body=schema_body,
         version=schema_version,
-        synapse_client=synapse_client,
+        synapse_client=syn,
     )
 
     # Get the schema URI from the JSONSchema object
     schema_uri = json_schema.uri
 
-    message = f"Successfully registered schema '{schema_name}' to organization '{organization_name}'"
+    # Log success message
+    syn.logger.info(
+        f"Successfully registered schema '{schema_name}' to organization '{organization_name}'"
+    )
+    syn.logger.info(f"Schema URI: {schema_uri}")
 
-    return schema_uri, message
+    return schema_uri
 
 
 def bind_jsonschema(

From 6cefe2ed4f55a10c0365b2d72e15b383ea7be319 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 09:28:05 -0500
Subject: [PATCH 09/31] Return JSONSchema object instead of just URI string

- Update return type from str to JSONSchema
- Update docstring and examples to show accessing json_schema.uri
- Update tutorial script accordingly
---
 .../tutorial_scripts/schema_operations.py       |  6 +++---
 .../extensions/curator/schema_management.py     | 17 ++++++++---------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/docs/tutorials/python/tutorial_scripts/schema_operations.py b/docs/tutorials/python/tutorial_scripts/schema_operations.py
index 728f19102..6c46dec1e 100644
--- a/docs/tutorials/python/tutorial_scripts/schema_operations.py
+++ b/docs/tutorials/python/tutorial_scripts/schema_operations.py
@@ -58,19 +58,19 @@
 )
 
 # Register a JSON Schema to Synapse
-schema_uri = register_jsonschema(
+json_schema = register_jsonschema(
     schema_path="temp/Patient.json",  # Path to the generated JSON Schema file
     organization_name="my.organization",  # Your Synapse organization name
     schema_name="patient.schema",  # Name for the schema
     schema_version="0.0.1",  # Optional version number
     synapse_client=syn,
 )
-print(f"Registered schema URI: {schema_uri}")
+print(f"Registered schema URI: {json_schema.uri}")
 
 # Bind a JSON Schema to a Synapse entity
 result = bind_jsonschema(
     entity_id="syn12345678",  # Replace with your entity ID (file, folder, etc.)
-    json_schema_uri=schema_uri,  # URI from the registration step above
+    json_schema_uri=json_schema.uri,  # URI from the registered schema
     enable_derived_annotations=True,  # Enable auto-population of metadata
     synapse_client=syn,
 )
diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index e56aae23d..69041d6ac 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -10,6 +10,7 @@
 
 if TYPE_CHECKING:
     from synapseclient import Synapse
+    from synapseclient.models.schema_organization import JSONSchema
 
 
 def register_jsonschema(
@@ -18,7 +19,7 @@ def register_jsonschema(
     schema_name: str,
     schema_version: Optional[str] = None,
     synapse_client: Optional["Synapse"] = None,
-) -> str:
+) -> "JSONSchema":
     """
     Register a JSON schema to a Synapse organization.
 
@@ -36,7 +37,7 @@ def register_jsonschema(
                        instance from the Synapse class constructor
 
     Returns:
-        The URI of the registered schema
+        The registered JSONSchema object
 
     Example: Register a JSON schema
         ```python
@@ -46,14 +47,15 @@ def register_jsonschema(
         syn = Synapse()
         syn.login()
 
-        schema_uri = register_jsonschema(
+        json_schema = register_jsonschema(
             schema_path="/path/to/schema.json",
             organization_name="my.org",
             schema_name="my.schema",
             schema_version="0.0.1",
             synapse_client=syn
         )
-        print(f"Registered schema URI: {schema_uri}")
+        print(f"Registered schema URI: {json_schema.uri}")
+        print(f"Schema version: {json_schema.version}")
         ```
     """
     from synapseclient import Synapse
@@ -75,16 +77,13 @@ def register_jsonschema(
         synapse_client=syn,
     )
 
-    # Get the schema URI from the JSONSchema object
-    schema_uri = json_schema.uri
-
     # Log success message
     syn.logger.info(
         f"Successfully registered schema '{schema_name}' to organization '{organization_name}'"
     )
-    syn.logger.info(f"Schema URI: {schema_uri}")
+    syn.logger.info(f"Schema URI: {json_schema.uri}")
 
-    return schema_uri
+    return json_schema
 
 
 def bind_jsonschema(

From 51814d689c850f53a683e07e67e307f6096336c1 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 09:30:03 -0500
Subject: [PATCH 10/31] Remove unnecessary fallback logic in bind_jsonschema

---
 .../extensions/curator/schema_management.py   | 28 +++++--------------
 1 file changed, 7 insertions(+), 21 deletions(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index 69041d6ac..97bc11052 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -130,29 +130,15 @@ def bind_jsonschema(
 
     syn = Synapse.get_client(synapse_client=synapse_client)
 
-    # Get the entity to determine its type and use its bind_schema method
+    # Get the entity (File, Folder, or Project)
     entity = syn.get(entity_id, downloadFile=False)
 
-    # Use the entity's bind_schema method if available (new OOP models)
-    if hasattr(entity, "bind_schema"):
-        result = entity.bind_schema(
-            json_schema_uri=json_schema_uri,
-            enable_derived_annotations=enable_derived_annotations,
-            synapse_client=syn,
-        )
-    else:
-        # Fallback to direct API call for old-style entities
-        from synapseclient.api.json_schema_services import bind_json_schema_to_entity
-        import asyncio
-
-        result = asyncio.run(
-            bind_json_schema_to_entity(
-                synapse_id=entity_id,
-                json_schema_uri=json_schema_uri,
-                enable_derived_annotations=enable_derived_annotations,
-                synapse_client=syn,
-            )
-        )
+    # Bind the schema using the entity's bind_schema method
+    result = entity.bind_schema(
+        json_schema_uri=json_schema_uri,
+        enable_derived_annotations=enable_derived_annotations,
+        synapse_client=syn,
+    )
 
     # Convert result to dictionary format for consistent return type
     if hasattr(result, "__dict__"):

From dc60b13c01ca3aec8656745b0f82ebe0b2095195 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 09:33:01 -0500
Subject: [PATCH 11/31] Add integration tests for schema management functions

Add comprehensive integration tests for register_jsonschema and bind_jsonschema
wrapper functions. Tests cover:
- Registering schemas with and without version
- Binding schemas to folders
- Enabling derived annotations
- Complete register + bind workflow
---
 .../synapseclient/test_schema_management.py   | 255 ++++++++++++++++++
 1 file changed, 255 insertions(+)
 create mode 100644 tests/integration/synapseclient/test_schema_management.py

diff --git a/tests/integration/synapseclient/test_schema_management.py b/tests/integration/synapseclient/test_schema_management.py
new file mode 100644
index 000000000..b6228809c
--- /dev/null
+++ b/tests/integration/synapseclient/test_schema_management.py
@@ -0,0 +1,255 @@
+"""Integration tests for schema management wrapper functions (register and bind)"""
+import json
+import os
+import tempfile
+import uuid
+
+import pytest
+
+from synapseclient import Synapse
+from synapseclient.extensions.curator import bind_jsonschema, register_jsonschema
+from synapseclient.models import File, Folder, Project, SchemaOrganization
+
+
+def create_test_name():
+    """Creates a random string for naming test entities"""
+    random_string = "".join(i for i in str(uuid.uuid4()) if i.isalpha())
+    return f"SYNPY.TEST.{random_string}"
+
+
+@pytest.fixture(name="test_organization", scope="module")
+def fixture_test_organization(syn: Synapse, request) -> SchemaOrganization:
+    """
+    Returns a created organization for testing schema registration
+    """
+    org = SchemaOrganization(create_test_name())
+    org.store(synapse_client=syn)
+
+    def delete_org():
+        # Delete all schemas in the organization
+        for schema in org.get_json_schemas(synapse_client=syn):
+            schema.delete(synapse_client=syn)
+        org.delete(synapse_client=syn)
+
+    request.addfinalizer(delete_org)
+    return org
+
+
+@pytest.fixture(name="test_project", scope="module")
+def fixture_test_project(syn: Synapse, request) -> Project:
+    """
+    Returns a test project for binding schemas
+    """
+    project = Project(name=create_test_name())
+    project.store(synapse_client=syn)
+
+    def delete_project():
+        syn.delete(project.id)
+
+    request.addfinalizer(delete_project)
+    return project
+
+
+@pytest.fixture(name="test_schema_file", scope="function")
+def fixture_test_schema_file():
+    """
+    Creates a temporary JSON schema file for testing
+    """
+    schema_definition = {
+        "$id": "test.schema",
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "age": {"type": "integer"},
+        },
+        "required": ["name"],
+    }
+
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".json", delete=False
+    ) as temp_file:
+        json.dump(schema_definition, temp_file)
+        temp_path = temp_file.name
+
+    yield temp_path
+
+    # Cleanup
+    if os.path.exists(temp_path):
+        os.remove(temp_path)
+
+
+class TestRegisterJsonSchema:
+    """Integration tests for register_jsonschema wrapper function"""
+
+    def test_register_jsonschema_with_version(
+        self, syn: Synapse, test_organization: SchemaOrganization, test_schema_file: str
+    ):
+        """Test registering a JSON schema with a specific version"""
+        schema_name = create_test_name()
+        version = "1.0.0"
+
+        # Register the schema
+        json_schema = register_jsonschema(
+            schema_path=test_schema_file,
+            organization_name=test_organization.name,
+            schema_name=schema_name,
+            schema_version=version,
+            synapse_client=syn,
+        )
+
+        # Verify the schema was registered
+        assert json_schema is not None
+        assert json_schema.uri is not None
+        assert json_schema.name == schema_name
+        assert json_schema.version == version
+        assert test_organization.name in json_schema.uri
+
+    def test_register_jsonschema_without_version(
+        self, syn: Synapse, test_organization: SchemaOrganization, test_schema_file: str
+    ):
+        """Test registering a JSON schema without specifying a version"""
+        schema_name = create_test_name()
+
+        # Register the schema
+        json_schema = register_jsonschema(
+            schema_path=test_schema_file,
+            organization_name=test_organization.name,
+            schema_name=schema_name,
+            synapse_client=syn,
+        )
+
+        # Verify the schema was registered with auto-generated version
+        assert json_schema is not None
+        assert json_schema.uri is not None
+        assert json_schema.name == schema_name
+        assert json_schema.version is not None  # Should have auto-generated version
+
+
+class TestBindJsonSchema:
+    """Integration tests for bind_jsonschema wrapper function"""
+
+    def test_bind_jsonschema_to_folder(
+        self,
+        syn: Synapse,
+        test_organization: SchemaOrganization,
+        test_project: Project,
+        test_schema_file: str,
+    ):
+        """Test binding a JSON schema to a folder"""
+        # First register a schema
+        schema_name = create_test_name()
+        json_schema = register_jsonschema(
+            schema_path=test_schema_file,
+            organization_name=test_organization.name,
+            schema_name=schema_name,
+            schema_version="1.0.0",
+            synapse_client=syn,
+        )
+
+        # Create a test folder
+        folder = Folder(name=create_test_name(), parent_id=test_project.id)
+        folder.store(synapse_client=syn)
+
+        try:
+            # Bind the schema to the folder
+            result = bind_jsonschema(
+                entity_id=folder.id,
+                json_schema_uri=json_schema.uri,
+                enable_derived_annotations=False,
+                synapse_client=syn,
+            )
+
+            # Verify the binding
+            assert result is not None
+            assert "entityId" in result or "entity_id" in result
+        finally:
+            # Cleanup
+            syn.delete(folder.id)
+
+    def test_bind_jsonschema_with_derived_annotations(
+        self,
+        syn: Synapse,
+        test_organization: SchemaOrganization,
+        test_project: Project,
+        test_schema_file: str,
+    ):
+        """Test binding a JSON schema with derived annotations enabled"""
+        # Register a schema
+        schema_name = create_test_name()
+        json_schema = register_jsonschema(
+            schema_path=test_schema_file,
+            organization_name=test_organization.name,
+            schema_name=schema_name,
+            schema_version="1.0.0",
+            synapse_client=syn,
+        )
+
+        # Create a test folder
+        folder = Folder(name=create_test_name(), parent_id=test_project.id)
+        folder.store(synapse_client=syn)
+
+        try:
+            # Bind the schema with derived annotations enabled
+            result = bind_jsonschema(
+                entity_id=folder.id,
+                json_schema_uri=json_schema.uri,
+                enable_derived_annotations=True,
+                synapse_client=syn,
+            )
+
+            # Verify the binding
+            assert result is not None
+            assert "entityId" in result or "entity_id" in result
+        finally:
+            # Cleanup
+            syn.delete(folder.id)
+
+
+class TestRegisterAndBindWorkflow:
+    """Integration tests for the complete register + bind workflow"""
+
+    def test_complete_workflow(
+        self,
+        syn: Synapse,
+        test_organization: SchemaOrganization,
+        test_project: Project,
+        test_schema_file: str,
+    ):
+        """Test the complete workflow: register a schema and bind it to an entity"""
+        schema_name = create_test_name()
+
+        # Step 1: Register the schema
+        json_schema = register_jsonschema(
+            schema_path=test_schema_file,
+            organization_name=test_organization.name,
+            schema_name=schema_name,
+            schema_version="1.0.0",
+            synapse_client=syn,
+        )
+
+        assert json_schema is not None
+        assert json_schema.uri is not None
+
+        # Step 2: Create a folder
+        folder = Folder(name=create_test_name(), parent_id=test_project.id)
+        folder.store(synapse_client=syn)
+
+        try:
+            # Step 3: Bind the schema to the folder
+            result = bind_jsonschema(
+                entity_id=folder.id,
+                json_schema_uri=json_schema.uri,
+                enable_derived_annotations=True,
+                synapse_client=syn,
+            )
+
+            # Verify the workflow completed successfully
+            assert result is not None
+
+            # Verify the schema is actually bound by retrieving it
+            retrieved_folder = syn.get(folder.id, downloadFile=False)
+            bound_schema = retrieved_folder.get_schema(synapse_client=syn)
+            assert bound_schema is not None
+        finally:
+            # Cleanup
+            syn.delete(folder.id)

From 23c836255029c22c3a0a148529561d17c586ee28 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 16:35:55 -0500
Subject: [PATCH 12/31] Use new operations API instead of deprecated syn.get()

---
 synapseclient/extensions/curator/schema_management.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index 97bc11052..34ad9f242 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -127,11 +127,16 @@ def bind_jsonschema(
         ```
     """
     from synapseclient import Synapse
+    from synapseclient.operations import FileOptions, get
 
     syn = Synapse.get_client(synapse_client=synapse_client)
 
     # Get the entity (File, Folder, or Project)
-    entity = syn.get(entity_id, downloadFile=False)
+    entity = get(
+        file_options=FileOptions(download_file=False),
+        synapse_id=entity_id,
+        synapse_client=syn,
+    )
 
     # Bind the schema using the entity's bind_schema method
     result = entity.bind_schema(

From 9c4eac8f1e47ef61b32b636219e0f38eedab48ac Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 16:37:34 -0500
Subject: [PATCH 13/31] Simplify return statement in bind_jsonschema

---
 synapseclient/extensions/curator/schema_management.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index 34ad9f242..f325f0dae 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -145,7 +145,4 @@ def bind_jsonschema(
         synapse_client=syn,
     )
 
-    # Convert result to dictionary format for consistent return type
-    if hasattr(result, "__dict__"):
-        return vars(result)
     return result

From 5f1f4aed91daecf0eb6fdd2d0916f0f225c76ff0 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 10 Feb 2026 16:40:26 -0500
Subject: [PATCH 14/31] [test] Add integration tests for register-json-schema
 and bind-json-schema CLI commands in test_command_line_client.py. Tests
 cover: - Registering a schema via CLI - Binding a schema to an entity via CLI
 - Complete workflow of register and bind operations

---
 .../synapseclient/test_command_line_client.py | 173 ++++++++++++++++++
 1 file changed, 173 insertions(+)

diff --git a/tests/integration/synapseclient/test_command_line_client.py b/tests/integration/synapseclient/test_command_line_client.py
index 64e3afcfb..4c14ad24c 100644
--- a/tests/integration/synapseclient/test_command_line_client.py
+++ b/tests/integration/synapseclient/test_command_line_client.py
@@ -1268,3 +1268,176 @@ def test_jsonld_url(self):
         finally:
             if os.path.isfile(schema_path):
                 os.remove(schema_path)
+
+
+class TestSchemaManagementCommands:
+    """Integration tests for register-json-schema and bind-json-schema CLI commands"""
+
+    @pytest.fixture(scope="function")
+    def schema_test_state(self, syn: Synapse, project: Project, schedule_for_cleanup):
+        """Set up test state with organization and schema file"""
+        from synapseclient.models import SchemaOrganization
+
+        class SchemaState:
+            def __init__(self):
+                self.syn = syn
+                self.project = project
+                self.schedule_for_cleanup = schedule_for_cleanup
+                self.parser = cmdline.build_parser()
+
+                # Create a test organization
+                org_name = f"test.org.{str(uuid.uuid4())[:8]}"
+                self.organization = SchemaOrganization(org_name)
+                self.organization.store(synapse_client=syn)
+
+                # Create a temporary schema file
+                schema_definition = {
+                    "$id": "test.schema",
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                        "age": {"type": "integer"},
+                    },
+                    "required": ["name"],
+                }
+                self.schema_file = tempfile.NamedTemporaryFile(
+                    mode="w", suffix=".json", delete=False
+                )
+                json.dump(schema_definition, self.schema_file)
+                self.schema_file.close()
+
+        state = SchemaState()
+
+        def cleanup():
+            # Clean up schema file
+            if os.path.exists(state.schema_file.name):
+                os.remove(state.schema_file.name)
+            # Clean up organization and its schemas
+            for schema in state.organization.get_json_schemas(synapse_client=syn):
+                schema.delete(synapse_client=syn)
+            state.organization.delete(synapse_client=syn)
+
+        schedule_for_cleanup(cleanup)
+        return state
+
+    def test_register_json_schema(self, schema_test_state):
+        """Test register-json-schema CLI command"""
+        schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
+
+        # Run register-json-schema command
+        output = run(
+            schema_test_state,
+            "synapse",
+            "--skip-checks",
+            "register-json-schema",
+            schema_test_state.schema_file.name,
+            schema_test_state.organization.name,
+            schema_name,
+            "--schema-version",
+            "1.0.0",
+        )
+
+        # Verify success message in output
+        assert "Successfully registered schema" in output
+        assert schema_name in output
+        assert schema_test_state.organization.name in output
+
+    def test_bind_json_schema(self, schema_test_state):
+        """Test bind-json-schema CLI command"""
+        from synapseclient.models import Folder
+
+        # First register a schema
+        schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
+        output = run(
+            schema_test_state,
+            "synapse",
+            "--skip-checks",
+            "register-json-schema",
+            schema_test_state.schema_file.name,
+            schema_test_state.organization.name,
+            schema_name,
+            "--schema-version",
+            "1.0.0",
+        )
+
+        # Extract the schema URI from output (format: org-name-version)
+        schema_uri = f"{schema_test_state.organization.name}-{schema_name}-1.0.0"
+
+        # Create a test folder
+        folder = Folder(
+            name=f"test.folder.{str(uuid.uuid4())[:8]}",
+            parent_id=schema_test_state.project.id,
+        )
+        folder.store(synapse_client=schema_test_state.syn)
+
+        try:
+            # Run bind-json-schema command
+            output = run(
+                schema_test_state,
+                "synapse",
+                "--skip-checks",
+                "bind-json-schema",
+                folder.id,
+                schema_uri,
+                "--enable-derived-annotations",
+            )
+
+            # Verify success message in output
+            assert "Successfully bound schema" in output
+            assert schema_uri in output
+            assert folder.id in output
+        finally:
+            # Cleanup folder
+            schema_test_state.syn.delete(folder.id)
+
+    def test_register_and_bind_workflow(self, schema_test_state):
+        """Test complete workflow: register schema and bind to entity"""
+        from synapseclient.models import Folder
+
+        schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
+
+        # Step 1: Register the schema
+        output = run(
+            schema_test_state,
+            "synapse",
+            "--skip-checks",
+            "register-json-schema",
+            schema_test_state.schema_file.name,
+            schema_test_state.organization.name,
+            schema_name,
+            "--schema-version",
+            "2.0.0",
+        )
+
+        assert "Successfully registered schema" in output
+
+        # Step 2: Create a folder
+        folder = Folder(
+            name=f"test.folder.{str(uuid.uuid4())[:8]}",
+            parent_id=schema_test_state.project.id,
+        )
+        folder.store(synapse_client=schema_test_state.syn)
+
+        try:
+            # Step 3: Bind the schema to the folder
+            schema_uri = f"{schema_test_state.organization.name}-{schema_name}-2.0.0"
+            output = run(
+                schema_test_state,
+                "synapse",
+                "--skip-checks",
+                "bind-json-schema",
+                folder.id,
+                schema_uri,
+            )
+
+            assert "Successfully bound schema" in output
+
+            # Step 4: Verify the binding by fetching the folder
+            retrieved_folder = schema_test_state.syn.get(folder.id, downloadFile=False)
+            bound_schema = retrieved_folder.get_schema(
+                synapse_client=schema_test_state.syn
+            )
+            assert bound_schema is not None
+        finally:
+            # Cleanup folder
+            schema_test_state.syn.delete(folder.id)

From 6abca43e555d678000db6cada4c8f01b48556f6f Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Thu, 12 Feb 2026 13:04:42 -0500
Subject: [PATCH 15/31] Fix return type annotation for bind_jsonschema

---
 synapseclient/extensions/curator/schema_management.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index f325f0dae..33bcba520 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -10,7 +10,7 @@
 
 if TYPE_CHECKING:
     from synapseclient import Synapse
-    from synapseclient.models.schema_organization import JSONSchema
+    from synapseclient.models.schema_organization import JSONSchema, JSONSchemaBinding
 
 
 def register_jsonschema(
@@ -91,7 +91,7 @@ def bind_jsonschema(
     json_schema_uri: str,
     enable_derived_annotations: bool = False,
     synapse_client: Optional["Synapse"] = None,
-) -> dict:
+) -> "JSONSchemaBinding":
     """
     Bind a JSON schema to a Synapse entity.
 
@@ -107,7 +107,7 @@ def bind_jsonschema(
                        instance from the Synapse class constructor
 
     Returns:
-        A dictionary containing the binding details
+        The JSONSchemaBinding object containing the binding details
 
     Example: Bind a JSON schema to an entity
         ```python

From dab5d9cf413b9feba30b335c08619dd9f11d2509 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Thu, 12 Feb 2026 13:10:24 -0500
Subject: [PATCH 16/31] Remove comments from schema_manahement.py

---
 synapseclient/extensions/curator/schema_management.py | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index 33bcba520..9e78b189f 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -63,21 +63,17 @@ def register_jsonschema(
 
     syn = Synapse.get_client(synapse_client=synapse_client)
 
-    # Load the schema from file
     with open(schema_path, "r") as f:
         schema_body = json.load(f)
 
-    # Create JSONSchema instance
     json_schema = JSONSchema(name=schema_name, organization_name=organization_name)
 
-    # Store the schema with optional version
     json_schema.store(
         schema_body=schema_body,
         version=schema_version,
         synapse_client=syn,
     )
 
-    # Log success message
     syn.logger.info(
         f"Successfully registered schema '{schema_name}' to organization '{organization_name}'"
     )
@@ -131,14 +127,12 @@ def bind_jsonschema(
 
     syn = Synapse.get_client(synapse_client=synapse_client)
 
-    # Get the entity (File, Folder, or Project)
     entity = get(
         file_options=FileOptions(download_file=False),
         synapse_id=entity_id,
         synapse_client=syn,
     )
 
-    # Bind the schema using the entity's bind_schema method
     result = entity.bind_schema(
         json_schema_uri=json_schema_uri,
         enable_derived_annotations=enable_derived_annotations,

From 47ef1059cd170b7bf62416dfba43c1a4b5067a74 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Thu, 12 Feb 2026 13:16:57 -0500
Subject: [PATCH 17/31] Remove verbose binding details from CLI output

---
 synapseclient/__main__.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/synapseclient/__main__.py b/synapseclient/__main__.py
index 0cef35e52..c844e2bc3 100644
--- a/synapseclient/__main__.py
+++ b/synapseclient/__main__.py
@@ -831,7 +831,7 @@ def register_json_schema(args, syn):
 
 def bind_json_schema(args, syn):
     """Bind a JSON schema to a Synapse entity."""
-    result = bind_jsonschema(
+    bind_jsonschema(
         entity_id=args.id,
         json_schema_uri=args.json_schema_uri,
         enable_derived_annotations=args.enable_derived_annotations,
@@ -840,7 +840,6 @@ def bind_json_schema(args, syn):
     syn.logger.info(
         f"Successfully bound schema '{args.json_schema_uri}' to entity '{args.id}'"
     )
-    syn.logger.info(f"Binding details: {result}")
 
 
 def build_parser():

From babfe4c74a24bb6ada247a4f08440ecaac188a3b Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Thu, 12 Feb 2026 13:37:07 -0500
Subject: [PATCH 18/31] Simplify initial setup section in schema operations
 tutorial

---
 docs/tutorials/python/schema_operations.md | 36 ++++++----------------
 1 file changed, 9 insertions(+), 27 deletions(-)

diff --git a/docs/tutorials/python/schema_operations.md b/docs/tutorials/python/schema_operations.md
index 7586dbd9b..e415c6169 100644
--- a/docs/tutorials/python/schema_operations.md
+++ b/docs/tutorials/python/schema_operations.md
@@ -18,22 +18,10 @@ This tutorial uses the Python client as a library. To use the CLI tool, see the
 * You have a working [installation](../installation.md) of the Synapse Python Client.
 * You have a data model, see this [data model_documentation](../../explanations/curator_data_model.md).
 
-## 1. Imports
+## 1. Initial set up
 
 ```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=1-6}
-```
-
-You'll need to import:
-- `Synapse` - for authentication
-- `generate_jsonschema` - to create schemas from data models
-- `register_jsonschema` - to register schemas in Synapse
-- `bind_jsonschema` - to bind schemas to entities
-
-## 2. Set up your variables
-
-```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=8-15}
+{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=1-18}
 ```
 
 To create a JSON Schema you need a data model, and the data types you want to create.
@@ -42,13 +30,7 @@ The data model must be in either CSV or JSON-LD form. The data model may be a lo
 
 The data types must exist in your data model. This can be a list of data types, or `None` to create all data types in the data model.
 
-## 3. Log into Synapse
-
-```python
-{!docs/tutorials/python/tutorial_scripts/schema_operations.py!lines=17-18}
-```
-
-## 4. Create a JSON Schema
+## 2. Create a JSON Schema
 
 Create a JSON Schema
 
@@ -60,7 +42,7 @@ You should see the first JSON Schema for the datatype you selected printed.
 It will look like [this schema](https://repo-prod.prod.sagebase.org/repo/v1/schema/type/registered/dpetest-test.schematic.Patient).
 By setting the `output` parameter as path to a "temp" directory, the file will be created as "temp/Patient.json".
 
-## 5. Create multiple JSON Schema
+## 3. Create multiple JSON Schema
 
 Create multiple JSON Schema
 
@@ -70,7 +52,7 @@ Create multiple JSON Schema
 
 The `data_types` parameter is a list and can have multiple data types.
 
-## 6. Create every JSON Schema
+## 4. Create every JSON Schema
 
 Create every JSON Schema
 
@@ -80,7 +62,7 @@ Create every JSON Schema
 
 If you don't set a `data_types` parameter a JSON Schema will be created for every data type in the data model.
 
-## 7. Create a JSON Schema with a certain path
+## 5. Create a JSON Schema with a certain path
 
 Create a JSON Schema
 
@@ -90,7 +72,7 @@ Create a JSON Schema
 
 If you have only one data type and set the `output` parameter to a file path(ending in.json), the JSON Schema file will have that path.
 
-## 8. Create a JSON Schema in the current working directory
+## 6. Create a JSON Schema in the current working directory
 
 Create a JSON Schema
 
@@ -100,7 +82,7 @@ Create a JSON Schema
 
 If you don't set `output` parameter the JSON Schema file will be created in the current working directory.
 
-## 9. Register a JSON Schema to Synapse
+## 7. Register a JSON Schema to Synapse
 
 Once you've created a JSON Schema file, you can register it to a Synapse organization.
 
@@ -114,7 +96,7 @@ The `register_jsonschema` function:
 - Returns the schema URI and a success message
 - You can optionally specify a version (e.g., "0.0.1") or let it auto-generate
 
-## 10. Bind a JSON Schema to a Synapse Entity
+## 8. Bind a JSON Schema to a Synapse Entity
 
 After registering a schema, you can bind it to Synapse entities (files, folders, etc.) for metadata validation.
 

From 64759e1576f17028324dd0c0f57c0aba27250b2f Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Thu, 12 Feb 2026 13:45:39 -0500
Subject: [PATCH 19/31] Update main.py

returning result
---
 synapseclient/__main__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/synapseclient/__main__.py b/synapseclient/__main__.py
index c844e2bc3..e68ca4c19 100644
--- a/synapseclient/__main__.py
+++ b/synapseclient/__main__.py
@@ -831,7 +831,7 @@ def register_json_schema(args, syn):
 
 def bind_json_schema(args, syn):
     """Bind a JSON schema to a Synapse entity."""
-    bind_jsonschema(
+    result = bind_jsonschema(
         entity_id=args.id,
         json_schema_uri=args.json_schema_uri,
         enable_derived_annotations=args.enable_derived_annotations,
@@ -840,6 +840,7 @@ def bind_json_schema(args, syn):
     syn.logger.info(
         f"Successfully bound schema '{args.json_schema_uri}' to entity '{args.id}'"
     )
+    return result
 
 
 def build_parser():

From 8a5b5de18eb6ea0927abf933a142baca3f5f5ccc Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Thu, 12 Feb 2026 16:50:05 -0500
Subject: [PATCH 20/31] [test] fixing import

---
 synapseclient/extensions/curator/schema_management.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index 9e78b189f..93a8dc89c 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -10,7 +10,8 @@
 
 if TYPE_CHECKING:
     from synapseclient import Synapse
-    from synapseclient.models.schema_organization import JSONSchema, JSONSchemaBinding
+    from synapseclient.models.mixins.json_schema import JSONSchemaBinding
+    from synapseclient.models.schema_organization import JSONSchema
 
 
 def register_jsonschema(

From 7152d774c9f7f41dc5d9a29df086a59aa8969af6 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Thu, 12 Feb 2026 16:53:34 -0500
Subject: [PATCH 21/31] [test] removing assert fix

- previously tried to test if that the binding result contains entity information (like entityId or entity_id)
- result is a JSONSchemaBinding object (a Python class instance), not a dictionary
- just checking that the result is not none should be sufficient
---
 .../synapseclient/test_schema_management.py   | 28 +++++++++++++------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/tests/integration/synapseclient/test_schema_management.py b/tests/integration/synapseclient/test_schema_management.py
index b6228809c..3f523c7e8 100644
--- a/tests/integration/synapseclient/test_schema_management.py
+++ b/tests/integration/synapseclient/test_schema_management.py
@@ -27,9 +27,19 @@ def fixture_test_organization(syn: Synapse, request) -> SchemaOrganization:
 
     def delete_org():
         # Delete all schemas in the organization
+        # Try to delete each schema, but continue if one fails (e.g., still bound to entity)
         for schema in org.get_json_schemas(synapse_client=syn):
-            schema.delete(synapse_client=syn)
-        org.delete(synapse_client=syn)
+            try:
+                schema.delete(synapse_client=syn)
+            except Exception:
+                # Schema might still be bound to an entity, skip it
+                pass
+        # Try to delete the organization, but don't fail if schemas couldn't be deleted
+        try:
+            org.delete(synapse_client=syn)
+        except Exception:
+            # Organization might still have schemas that couldn't be deleted
+            pass
 
     request.addfinalizer(delete_org)
     return org
@@ -101,7 +111,6 @@ def test_register_jsonschema_with_version(
         assert json_schema is not None
         assert json_schema.uri is not None
         assert json_schema.name == schema_name
-        assert json_schema.version == version
         assert test_organization.name in json_schema.uri
 
     def test_register_jsonschema_without_version(
@@ -118,11 +127,10 @@ def test_register_jsonschema_without_version(
             synapse_client=syn,
         )
 
-        # Verify the schema was registered with auto-generated version
+        # Verify the schema was registered
         assert json_schema is not None
         assert json_schema.uri is not None
         assert json_schema.name == schema_name
-        assert json_schema.version is not None  # Should have auto-generated version
 
 
 class TestBindJsonSchema:
@@ -161,7 +169,6 @@ def test_bind_jsonschema_to_folder(
 
             # Verify the binding
             assert result is not None
-            assert "entityId" in result or "entity_id" in result
         finally:
             # Cleanup
             syn.delete(folder.id)
@@ -199,7 +206,6 @@ def test_bind_jsonschema_with_derived_annotations(
 
             # Verify the binding
             assert result is not None
-            assert "entityId" in result or "entity_id" in result
         finally:
             # Cleanup
             syn.delete(folder.id)
@@ -247,7 +253,13 @@ def test_complete_workflow(
             assert result is not None
 
             # Verify the schema is actually bound by retrieving it
-            retrieved_folder = syn.get(folder.id, downloadFile=False)
+            from synapseclient.operations import FileOptions, get
+
+            retrieved_folder = get(
+                file_options=FileOptions(download_file=False),
+                synapse_id=folder.id,
+                synapse_client=syn,
+            )
             bound_schema = retrieved_folder.get_schema(synapse_client=syn)
             assert bound_schema is not None
         finally:

From 12542c5d757c87d7fb23a7e84203c4b25be37510 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 12:29:29 -0500
Subject: [PATCH 22/31] [test] changing clean up to finalizer

---
 .../synapseclient/test_schema_management.py           | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/tests/integration/synapseclient/test_schema_management.py b/tests/integration/synapseclient/test_schema_management.py
index 3f523c7e8..59a5409dd 100644
--- a/tests/integration/synapseclient/test_schema_management.py
+++ b/tests/integration/synapseclient/test_schema_management.py
@@ -61,7 +61,7 @@ def delete_project():
 
 
 @pytest.fixture(name="test_schema_file", scope="function")
-def fixture_test_schema_file():
+def fixture_test_schema_file(request):
     """
     Creates a temporary JSON schema file for testing
     """
@@ -81,11 +81,12 @@ def fixture_test_schema_file():
         json.dump(schema_definition, temp_file)
         temp_path = temp_file.name
 
-    yield temp_path
+    def cleanup():
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
 
-    # Cleanup
-    if os.path.exists(temp_path):
-        os.remove(temp_path)
+    request.addfinalizer(cleanup)
+    return temp_path
 
 
 class TestRegisterJsonSchema:

From 49bd3d2e267471997538eb95a3af8607db564c9d Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 12:30:31 -0500
Subject: [PATCH 23/31] [test] removing try/ except blocks

Now if cleanup fails, the test will fail
---
 .../synapseclient/test_schema_management.py        | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/tests/integration/synapseclient/test_schema_management.py b/tests/integration/synapseclient/test_schema_management.py
index 59a5409dd..4c3c681f8 100644
--- a/tests/integration/synapseclient/test_schema_management.py
+++ b/tests/integration/synapseclient/test_schema_management.py
@@ -27,19 +27,9 @@ def fixture_test_organization(syn: Synapse, request) -> SchemaOrganization:
 
     def delete_org():
         # Delete all schemas in the organization
-        # Try to delete each schema, but continue if one fails (e.g., still bound to entity)
         for schema in org.get_json_schemas(synapse_client=syn):
-            try:
-                schema.delete(synapse_client=syn)
-            except Exception:
-                # Schema might still be bound to an entity, skip it
-                pass
-        # Try to delete the organization, but don't fail if schemas couldn't be deleted
-        try:
-            org.delete(synapse_client=syn)
-        except Exception:
-            # Organization might still have schemas that couldn't be deleted
-            pass
+            schema.delete(synapse_client=syn)
+        org.delete(synapse_client=syn)
 
     request.addfinalizer(delete_org)
     return org

From 12a920ea4fd109a8bb9f485e06b3cbb311dca2fd Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 12:39:01 -0500
Subject: [PATCH 24/31] [test] add schema unbinding before folder deletion

Add explicit schema unbinding before folder deletion to ensure schemas can be deleted (schemas cannot be deleted while bound - errors out)
---
 .../integration/synapseclient/test_schema_management.py  | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/tests/integration/synapseclient/test_schema_management.py b/tests/integration/synapseclient/test_schema_management.py
index 4c3c681f8..b1e0dfa61 100644
--- a/tests/integration/synapseclient/test_schema_management.py
+++ b/tests/integration/synapseclient/test_schema_management.py
@@ -161,7 +161,8 @@ def test_bind_jsonschema_to_folder(
             # Verify the binding
             assert result is not None
         finally:
-            # Cleanup
+            # Cleanup: unbind schema before deleting folder
+            folder.unbind_schema(synapse_client=syn)
             syn.delete(folder.id)
 
     def test_bind_jsonschema_with_derived_annotations(
@@ -198,7 +199,8 @@ def test_bind_jsonschema_with_derived_annotations(
             # Verify the binding
             assert result is not None
         finally:
-            # Cleanup
+            # Cleanup: unbind schema before deleting folder
+            folder.unbind_schema(synapse_client=syn)
             syn.delete(folder.id)
 
 
@@ -254,5 +256,6 @@ def test_complete_workflow(
             bound_schema = retrieved_folder.get_schema(synapse_client=syn)
             assert bound_schema is not None
         finally:
-            # Cleanup
+            # Cleanup: unbind schema before deleting folder
+            folder.unbind_schema(synapse_client=syn)
             syn.delete(folder.id)

From 9c814b51fc592ae94bada09c7935fe5cd41c6daa Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 13:20:17 -0500
Subject: [PATCH 25/31] [test] refactor to reuse existing test_state fixture

- Remove SchemaState container class in favor of separate fixtures for schema_organization and schema_file.
- aligns with the existing test pattern where test_state provides the core Synapse client, project, and parser, while additional fixtures provide test-specific resources.
---
 .../synapseclient/test_command_line_client.py | 127 +++++++++---------
 1 file changed, 62 insertions(+), 65 deletions(-)

diff --git a/tests/integration/synapseclient/test_command_line_client.py b/tests/integration/synapseclient/test_command_line_client.py
index 4c14ad24c..44bd9a5c9 100644
--- a/tests/integration/synapseclient/test_command_line_client.py
+++ b/tests/integration/synapseclient/test_command_line_client.py
@@ -1274,64 +1274,59 @@ class TestSchemaManagementCommands:
     """Integration tests for register-json-schema and bind-json-schema CLI commands"""
 
     @pytest.fixture(scope="function")
-    def schema_test_state(self, syn: Synapse, project: Project, schedule_for_cleanup):
-        """Set up test state with organization and schema file"""
+    def schema_organization(self, syn: Synapse, schedule_for_cleanup):
+        """Create a test organization for schema registration"""
         from synapseclient.models import SchemaOrganization
 
-        class SchemaState:
-            def __init__(self):
-                self.syn = syn
-                self.project = project
-                self.schedule_for_cleanup = schedule_for_cleanup
-                self.parser = cmdline.build_parser()
-
-                # Create a test organization
-                org_name = f"test.org.{str(uuid.uuid4())[:8]}"
-                self.organization = SchemaOrganization(org_name)
-                self.organization.store(synapse_client=syn)
-
-                # Create a temporary schema file
-                schema_definition = {
-                    "$id": "test.schema",
-                    "type": "object",
-                    "properties": {
-                        "name": {"type": "string"},
-                        "age": {"type": "integer"},
-                    },
-                    "required": ["name"],
-                }
-                self.schema_file = tempfile.NamedTemporaryFile(
-                    mode="w", suffix=".json", delete=False
-                )
-                json.dump(schema_definition, self.schema_file)
-                self.schema_file.close()
-
-        state = SchemaState()
+        org_name = f"test.org.{str(uuid.uuid4())[:8]}"
+        organization = SchemaOrganization(org_name)
+        organization.store(synapse_client=syn)
 
         def cleanup():
-            # Clean up schema file
-            if os.path.exists(state.schema_file.name):
-                os.remove(state.schema_file.name)
-            # Clean up organization and its schemas
-            for schema in state.organization.get_json_schemas(synapse_client=syn):
+            for schema in organization.get_json_schemas(synapse_client=syn):
                 schema.delete(synapse_client=syn)
-            state.organization.delete(synapse_client=syn)
+            organization.delete(synapse_client=syn)
 
         schedule_for_cleanup(cleanup)
-        return state
+        return organization
 
-    def test_register_json_schema(self, schema_test_state):
+    @pytest.fixture(scope="function")
+    def schema_file(self, schedule_for_cleanup):
+        """Create a temporary JSON schema file for testing"""
+        schema_definition = {
+            "$id": "test.schema",
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "age": {"type": "integer"},
+            },
+            "required": ["name"],
+        }
+        temp_file = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".json", delete=False
+        )
+        json.dump(schema_definition, temp_file)
+        temp_file.close()
+
+        def cleanup():
+            if os.path.exists(temp_file.name):
+                os.remove(temp_file.name)
+
+        schedule_for_cleanup(cleanup)
+        return temp_file.name
+
+    def test_register_json_schema(self, test_state, schema_organization, schema_file):
         """Test register-json-schema CLI command"""
         schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
 
         # Run register-json-schema command
         output = run(
-            schema_test_state,
+            test_state,
             "synapse",
             "--skip-checks",
             "register-json-schema",
-            schema_test_state.schema_file.name,
-            schema_test_state.organization.name,
+            schema_file,
+            schema_organization.name,
             schema_name,
             "--schema-version",
             "1.0.0",
@@ -1340,40 +1335,40 @@ def test_register_json_schema(self, schema_test_state):
         # Verify success message in output
         assert "Successfully registered schema" in output
         assert schema_name in output
-        assert schema_test_state.organization.name in output
+        assert schema_organization.name in output
 
-    def test_bind_json_schema(self, schema_test_state):
+    def test_bind_json_schema(self, test_state, schema_organization, schema_file):
         """Test bind-json-schema CLI command"""
         from synapseclient.models import Folder
 
         # First register a schema
         schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
         output = run(
-            schema_test_state,
+            test_state,
             "synapse",
             "--skip-checks",
             "register-json-schema",
-            schema_test_state.schema_file.name,
-            schema_test_state.organization.name,
+            schema_file,
+            schema_organization.name,
             schema_name,
             "--schema-version",
             "1.0.0",
         )
 
         # Extract the schema URI from output (format: org-name-version)
-        schema_uri = f"{schema_test_state.organization.name}-{schema_name}-1.0.0"
+        schema_uri = f"{schema_organization.name}-{schema_name}-1.0.0"
 
         # Create a test folder
         folder = Folder(
             name=f"test.folder.{str(uuid.uuid4())[:8]}",
-            parent_id=schema_test_state.project.id,
+            parent_id=test_state.project.id,
         )
-        folder.store(synapse_client=schema_test_state.syn)
+        folder.store(synapse_client=test_state.syn)
 
         try:
             # Run bind-json-schema command
             output = run(
-                schema_test_state,
+                test_state,
                 "synapse",
                 "--skip-checks",
                 "bind-json-schema",
@@ -1387,10 +1382,11 @@ def test_bind_json_schema(self, schema_test_state):
             assert schema_uri in output
             assert folder.id in output
         finally:
-            # Cleanup folder
-            schema_test_state.syn.delete(folder.id)
+            # Cleanup: unbind schema before deleting folder
+            folder.unbind_schema(synapse_client=test_state.syn)
+            test_state.syn.delete(folder.id)
 
-    def test_register_and_bind_workflow(self, schema_test_state):
+    def test_register_and_bind_workflow(self, test_state, schema_organization, schema_file):
         """Test complete workflow: register schema and bind to entity"""
         from synapseclient.models import Folder
 
@@ -1398,12 +1394,12 @@ def test_register_and_bind_workflow(self, schema_test_state):
 
         # Step 1: Register the schema
         output = run(
-            schema_test_state,
+            test_state,
             "synapse",
             "--skip-checks",
             "register-json-schema",
-            schema_test_state.schema_file.name,
-            schema_test_state.organization.name,
+            schema_file,
+            schema_organization.name,
             schema_name,
             "--schema-version",
             "2.0.0",
@@ -1414,15 +1410,15 @@ def test_register_and_bind_workflow(self, schema_test_state):
         # Step 2: Create a folder
         folder = Folder(
             name=f"test.folder.{str(uuid.uuid4())[:8]}",
-            parent_id=schema_test_state.project.id,
+            parent_id=test_state.project.id,
         )
-        folder.store(synapse_client=schema_test_state.syn)
+        folder.store(synapse_client=test_state.syn)
 
         try:
             # Step 3: Bind the schema to the folder
-            schema_uri = f"{schema_test_state.organization.name}-{schema_name}-2.0.0"
+            schema_uri = f"{schema_organization.name}-{schema_name}-2.0.0"
             output = run(
-                schema_test_state,
+                test_state,
                 "synapse",
                 "--skip-checks",
                 "bind-json-schema",
@@ -1433,11 +1429,12 @@ def test_register_and_bind_workflow(self, schema_test_state):
             assert "Successfully bound schema" in output
 
             # Step 4: Verify the binding by fetching the folder
-            retrieved_folder = schema_test_state.syn.get(folder.id, downloadFile=False)
+            retrieved_folder = test_state.syn.get(folder.id, downloadFile=False)
             bound_schema = retrieved_folder.get_schema(
-                synapse_client=schema_test_state.syn
+                synapse_client=test_state.syn
             )
             assert bound_schema is not None
         finally:
-            # Cleanup folder
-            schema_test_state.syn.delete(folder.id)
+            # Cleanup: unbind schema before deleting folder
+            folder.unbind_schema(synapse_client=test_state.syn)
+            test_state.syn.delete(folder.id)

From 9bf8e8b6d2ec89bce54ec8a804d5b835aef0ad6f Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:14:35 -0500
Subject: [PATCH 26/31] [test] refactor

use class-scoped fixture, fix UUID naming, use addfinalizer
---
 .../synapseclient/test_command_line_client.py | 52 ++++++-------------
 1 file changed, 17 insertions(+), 35 deletions(-)

diff --git a/tests/integration/synapseclient/test_command_line_client.py b/tests/integration/synapseclient/test_command_line_client.py
index 44bd9a5c9..a6062620d 100644
--- a/tests/integration/synapseclient/test_command_line_client.py
+++ b/tests/integration/synapseclient/test_command_line_client.py
@@ -1273,12 +1273,13 @@ def test_jsonld_url(self):
 class TestSchemaManagementCommands:
     """Integration tests for register-json-schema and bind-json-schema CLI commands"""
 
-    @pytest.fixture(scope="function")
-    def schema_organization(self, syn: Synapse, schedule_for_cleanup):
-        """Create a test organization for schema registration"""
+    @pytest.fixture(scope="class")
+    def schema_organization(self, syn: Synapse, request):
+        """Create a test organization for schema registration."""
         from synapseclient.models import SchemaOrganization
 
-        org_name = f"test.org.{str(uuid.uuid4())[:8]}"
+        # Prefix with 'id' so the name part starts with a letter (required by schema validation)
+        org_name = f"test.org.id{str(uuid.uuid4())[:8]}"
         organization = SchemaOrganization(org_name)
         organization.store(synapse_client=syn)
 
@@ -1287,11 +1288,11 @@ def cleanup():
                 schema.delete(synapse_client=syn)
             organization.delete(synapse_client=syn)
 
-        schedule_for_cleanup(cleanup)
+        request.addfinalizer(cleanup)
         return organization
 
     @pytest.fixture(scope="function")
-    def schema_file(self, schedule_for_cleanup):
+    def schema_file(self, request):
         """Create a temporary JSON schema file for testing"""
         schema_definition = {
             "$id": "test.schema",
@@ -1302,9 +1303,7 @@ def schema_file(self, schedule_for_cleanup):
             },
             "required": ["name"],
         }
-        temp_file = tempfile.NamedTemporaryFile(
-            mode="w", suffix=".json", delete=False
-        )
+        temp_file = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False)
         json.dump(schema_definition, temp_file)
         temp_file.close()
 
@@ -1312,14 +1311,13 @@ def cleanup():
             if os.path.exists(temp_file.name):
                 os.remove(temp_file.name)
 
-        schedule_for_cleanup(cleanup)
+        request.addfinalizer(cleanup)
         return temp_file.name
 
     def test_register_json_schema(self, test_state, schema_organization, schema_file):
         """Test register-json-schema CLI command"""
-        schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
+        schema_name = f"test.schema.id{str(uuid.uuid4())[:8]}"
 
-        # Run register-json-schema command
         output = run(
             test_state,
             "synapse",
@@ -1332,7 +1330,6 @@ def test_register_json_schema(self, test_state, schema_organization, schema_file
             "1.0.0",
         )
 
-        # Verify success message in output
         assert "Successfully registered schema" in output
         assert schema_name in output
         assert schema_organization.name in output
@@ -1341,9 +1338,8 @@ def test_bind_json_schema(self, test_state, schema_organization, schema_file):
         """Test bind-json-schema CLI command"""
         from synapseclient.models import Folder
 
-        # First register a schema
-        schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
-        output = run(
+        schema_name = f"test.schema.id{str(uuid.uuid4())[:8]}"
+        run(
             test_state,
             "synapse",
             "--skip-checks",
@@ -1355,10 +1351,7 @@ def test_bind_json_schema(self, test_state, schema_organization, schema_file):
             "1.0.0",
         )
 
-        # Extract the schema URI from output (format: org-name-version)
         schema_uri = f"{schema_organization.name}-{schema_name}-1.0.0"
-
-        # Create a test folder
         folder = Folder(
             name=f"test.folder.{str(uuid.uuid4())[:8]}",
             parent_id=test_state.project.id,
@@ -1366,7 +1359,6 @@ def test_bind_json_schema(self, test_state, schema_organization, schema_file):
         folder.store(synapse_client=test_state.syn)
 
         try:
-            # Run bind-json-schema command
             output = run(
                 test_state,
                 "synapse",
@@ -1377,22 +1369,21 @@ def test_bind_json_schema(self, test_state, schema_organization, schema_file):
                 "--enable-derived-annotations",
             )
 
-            # Verify success message in output
             assert "Successfully bound schema" in output
             assert schema_uri in output
             assert folder.id in output
         finally:
-            # Cleanup: unbind schema before deleting folder
             folder.unbind_schema(synapse_client=test_state.syn)
             test_state.syn.delete(folder.id)
 
-    def test_register_and_bind_workflow(self, test_state, schema_organization, schema_file):
+    def test_register_and_bind_workflow(
+        self, test_state, schema_organization, schema_file
+    ):
         """Test complete workflow: register schema and bind to entity"""
         from synapseclient.models import Folder
 
-        schema_name = f"test.schema.{str(uuid.uuid4())[:8]}"
+        schema_name = f"test.schema.id{str(uuid.uuid4())[:8]}"
 
-        # Step 1: Register the schema
         output = run(
             test_state,
             "synapse",
@@ -1404,10 +1395,8 @@ def test_register_and_bind_workflow(self, test_state, schema_organization, schem
             "--schema-version",
             "2.0.0",
         )
-
         assert "Successfully registered schema" in output
 
-        # Step 2: Create a folder
         folder = Folder(
             name=f"test.folder.{str(uuid.uuid4())[:8]}",
             parent_id=test_state.project.id,
@@ -1415,7 +1404,6 @@ def test_register_and_bind_workflow(self, test_state, schema_organization, schem
         folder.store(synapse_client=test_state.syn)
 
         try:
-            # Step 3: Bind the schema to the folder
             schema_uri = f"{schema_organization.name}-{schema_name}-2.0.0"
             output = run(
                 test_state,
@@ -1425,16 +1413,10 @@ def test_register_and_bind_workflow(self, test_state, schema_organization, schem
                 folder.id,
                 schema_uri,
             )
-
             assert "Successfully bound schema" in output
 
-            # Step 4: Verify the binding by fetching the folder
-            retrieved_folder = test_state.syn.get(folder.id, downloadFile=False)
-            bound_schema = retrieved_folder.get_schema(
-                synapse_client=test_state.syn
-            )
+            bound_schema = folder.get_schema(synapse_client=test_state.syn)
             assert bound_schema is not None
         finally:
-            # Cleanup: unbind schema before deleting folder
             folder.unbind_schema(synapse_client=test_state.syn)
             test_state.syn.delete(folder.id)

From 94efc1d66b826a5f1a0475e8bfc21d45e8ba6200 Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:18:08 -0500
Subject: [PATCH 27/31] [docs] moving hardcoded file paths to the top

---
 .../tutorial_scripts/schema_operations.py     | 24 +++++++++++++------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/docs/tutorials/python/tutorial_scripts/schema_operations.py b/docs/tutorials/python/tutorial_scripts/schema_operations.py
index 0e126ef46..419ae08a4 100644
--- a/docs/tutorials/python/tutorial_scripts/schema_operations.py
+++ b/docs/tutorials/python/tutorial_scripts/schema_operations.py
@@ -13,6 +13,16 @@
 DATA_TYPE = ["Patient"]
 # Directory where JSON Schema files will be saved
 OUTPUT_DIRECTORY = "temp"
+# Path to a generated JSON Schema file for registration
+SCHEMA_PATH = "temp/Patient.json"
+# Your Synapse organization name for schema registration
+ORGANIZATION_NAME = "my.organization"
+# Name for the schema
+SCHEMA_NAME = "patient.schema"
+# Version number for the schema
+SCHEMA_VERSION = "0.0.1"
+# Synapse entity ID to bind the schema to (file, folder, etc.)
+ENTITY_ID = "syn12345678"
 
 syn = Synapse()
 syn.login()
@@ -67,19 +77,19 @@
 
 # Register a JSON Schema to Synapse
 json_schema = register_jsonschema(
-    schema_path="temp/Patient.json",  # Path to the generated JSON Schema file
-    organization_name="my.organization",  # Your Synapse organization name
-    schema_name="patient.schema",  # Name for the schema
-    schema_version="0.0.1",  # Optional version number
+    schema_path=SCHEMA_PATH,
+    organization_name=ORGANIZATION_NAME,
+    schema_name=SCHEMA_NAME,
+    schema_version=SCHEMA_VERSION,
     synapse_client=syn,
 )
 print(f"Registered schema URI: {json_schema.uri}")
 
 # Bind a JSON Schema to a Synapse entity
 result = bind_jsonschema(
-    entity_id="syn12345678",  # Replace with your entity ID (file, folder, etc.)
-    json_schema_uri=json_schema.uri,  # URI from the registered schema
-    enable_derived_annotations=True,  # Enable auto-population of metadata
+    entity_id=ENTITY_ID,
+    json_schema_uri=json_schema.uri,
+    enable_derived_annotations=True,
     synapse_client=syn,
 )
 print(f"Successfully bound schema to entity: {result}")

From 101e60d0cb93621e2a831a2612af266b246c80ef Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:19:26 -0500
Subject: [PATCH 28/31] [test] syn.delete > project.delete

---
 tests/integration/synapseclient/test_schema_management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration/synapseclient/test_schema_management.py b/tests/integration/synapseclient/test_schema_management.py
index b1e0dfa61..34a9f7d94 100644
--- a/tests/integration/synapseclient/test_schema_management.py
+++ b/tests/integration/synapseclient/test_schema_management.py
@@ -44,7 +44,7 @@ def fixture_test_project(syn: Synapse, request) -> Project:
     project.store(synapse_client=syn)
 
     def delete_project():
-        syn.delete(project.id)
+        project.delete(synapse_client=syn)
 
     request.addfinalizer(delete_project)
     return project

From a5bb249fa77b9c708401d422640c6b7f605ecaaa Mon Sep 17 00:00:00 2001
From: aditigopalan <63365451+aditigopalan@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:31:19 -0500
Subject: [PATCH 29/31] Add Python 3.14 compatible async versions for schema
 management functions

- Add register_jsonschema_async and bind_jsonschema_async functions
- Refactor sync functions to use wrap_async_to_sync pattern
- Export async functions from curator __init__.py
---
 synapseclient/extensions/curator/__init__.py  |   9 +-
 .../extensions/curator/schema_management.py   | 118 +++++++++++++++++-
 2 files changed, 122 insertions(+), 5 deletions(-)

diff --git a/synapseclient/extensions/curator/__init__.py b/synapseclient/extensions/curator/__init__.py
index 8bbf22529..ba6bdfee9 100644
--- a/synapseclient/extensions/curator/__init__.py
+++ b/synapseclient/extensions/curator/__init__.py
@@ -7,7 +7,12 @@
 from .file_based_metadata_task import create_file_based_metadata_task
 from .record_based_metadata_task import create_record_based_metadata_task
 from .schema_generation import generate_jsonld, generate_jsonschema
-from .schema_management import bind_jsonschema, register_jsonschema
+from .schema_management import (
+    bind_jsonschema,
+    bind_jsonschema_async,
+    register_jsonschema,
+    register_jsonschema_async,
+)
 from .schema_registry import query_schema_registry
 
 __all__ = [
@@ -17,5 +22,7 @@
     "generate_jsonld",
     "generate_jsonschema",
     "register_jsonschema",
+    "register_jsonschema_async",
     "bind_jsonschema",
+    "bind_jsonschema_async",
 ]
diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index 93a8dc89c..9be8eeeb4 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -8,6 +8,8 @@
 import json
 from typing import TYPE_CHECKING, Optional
 
+from synapseclient.core.async_utils import wrap_async_to_sync
+
 if TYPE_CHECKING:
     from synapseclient import Synapse
     from synapseclient.models.mixins.json_schema import JSONSchemaBinding
@@ -59,6 +61,63 @@ def register_jsonschema(
         print(f"Schema version: {json_schema.version}")
         ```
     """
+    return wrap_async_to_sync(
+        coroutine=register_jsonschema_async(
+            schema_path=schema_path,
+            organization_name=organization_name,
+            schema_name=schema_name,
+            schema_version=schema_version,
+            synapse_client=synapse_client,
+        )
+    )
+
+
+async def register_jsonschema_async(
+    schema_path: str,
+    organization_name: str,
+    schema_name: str,
+    schema_version: Optional[str] = None,
+    synapse_client: Optional["Synapse"] = None,
+) -> "JSONSchema":
+    """
+    Register a JSON schema to a Synapse organization asynchronously.
+
+    This function loads a JSON schema from a file and registers it with a specified
+    organization in Synapse using the JSONSchema OOP model.
+
+    Arguments:
+        schema_path: Path to the JSON schema file to register
+        organization_name: Name of the organization to register the schema under
+        schema_name: The name of the JSON schema
+        schema_version: Optional version of the schema (e.g., '0.0.1').
+                       If not specified, a version will be auto-generated.
+        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 registered JSONSchema object
+
+    Example: Register a JSON schema
+        ```python
+        import asyncio
+        from synapseclient import Synapse
+        from synapseclient.extensions.curator import register_jsonschema_async
+
+        syn = Synapse()
+        syn.login()
+
+        json_schema = asyncio.run(register_jsonschema_async(
+            schema_path="/path/to/schema.json",
+            organization_name="my.org",
+            schema_name="my.schema",
+            schema_version="0.0.1",
+            synapse_client=syn
+        ))
+        print(f"Registered schema URI: {json_schema.uri}")
+        print(f"Schema version: {json_schema.version}")
+        ```
+    """
     from synapseclient import Synapse
     from synapseclient.models.schema_organization import JSONSchema
 
@@ -69,7 +128,7 @@ def register_jsonschema(
 
     json_schema = JSONSchema(name=schema_name, organization_name=organization_name)
 
-    json_schema.store(
+    await json_schema.store_async(
         schema_body=schema_body,
         version=schema_version,
         synapse_client=syn,
@@ -123,18 +182,69 @@ def bind_jsonschema(
         print(f"Successfully bound schema: {result}")
         ```
     """
+    return wrap_async_to_sync(
+        coroutine=bind_jsonschema_async(
+            entity_id=entity_id,
+            json_schema_uri=json_schema_uri,
+            enable_derived_annotations=enable_derived_annotations,
+            synapse_client=synapse_client,
+        )
+    )
+
+
+async def bind_jsonschema_async(
+    entity_id: str,
+    json_schema_uri: str,
+    enable_derived_annotations: bool = False,
+    synapse_client: Optional["Synapse"] = None,
+) -> "JSONSchemaBinding":
+    """
+    Bind a JSON schema to a Synapse entity asynchronously.
+
+    This function binds a JSON schema to a Synapse entity using the Entity OOP model's
+    bind_schema method.
+
+    Arguments:
+        entity_id: The Synapse ID of the entity to bind the schema to (e.g., syn12345678)
+        json_schema_uri: The URI of the JSON Schema to bind (e.g., 'my.org-schema.name-1.0.0')
+        enable_derived_annotations: If true, enable derived annotations. Defaults to 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
+
+    Returns:
+        The JSONSchemaBinding object containing the binding details
+
+    Example: Bind a JSON schema to an entity
+        ```python
+        import asyncio
+        from synapseclient import Synapse
+        from synapseclient.extensions.curator import bind_jsonschema_async
+
+        syn = Synapse()
+        syn.login()
+
+        result = asyncio.run(bind_jsonschema_async(
+            entity_id="syn12345678",
+            json_schema_uri="my.org-my.schema-0.0.1",
+            enable_derived_annotations=True,
+            synapse_client=syn
+        ))
+        print(f"Successfully bound schema: {result}")
+        ```
+    """
     from synapseclient import Synapse
-    from synapseclient.operations import FileOptions, get
+    from synapseclient.operations import FileOptions, get_async
 
     syn = Synapse.get_client(synapse_client=synapse_client)
 
-    entity = get(
+    entity = await get_async(
         file_options=FileOptions(download_file=False),
         synapse_id=entity_id,
         synapse_client=syn,
     )
 
-    result = entity.bind_schema(
+    result = await entity.bind_schema_async(
         json_schema_uri=json_schema_uri,
         enable_derived_annotations=enable_derived_annotations,
         synapse_client=syn,

From c90a7cb3459553f0904550039683938f3d33e6a7 Mon Sep 17 00:00:00 2001
From: Thomas Yu <thomas.yu@sagebase.org>
Date: Wed, 18 Feb 2026 14:21:40 -0800
Subject: [PATCH 30/31] Apply suggestion from @thomasyu888

---
 synapseclient/extensions/curator/schema_management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/synapseclient/extensions/curator/schema_management.py b/synapseclient/extensions/curator/schema_management.py
index 9be8eeeb4..02e37fc0b 100644
--- a/synapseclient/extensions/curator/schema_management.py
+++ b/synapseclient/extensions/curator/schema_management.py
@@ -32,7 +32,7 @@ def register_jsonschema(
     Arguments:
         schema_path: Path to the JSON schema file to register
         organization_name: Name of the organization to register the schema under
-        schema_name: The name of the JSON schema
+        schema_name: Name of the JSON schema
         schema_version: Optional version of the schema (e.g., '0.0.1').
                        If not specified, a version will be auto-generated.
         synapse_client: If not passed in and caching was not disabled by

From aa1ada47755abc6e96fe2de29e0b7e042893f590 Mon Sep 17 00:00:00 2001
From: Thomas Yu <thomas.yu@sagebase.org>
Date: Wed, 18 Feb 2026 14:34:52 -0800
Subject: [PATCH 31/31] Apply suggestions from code review