Synapse Python Client

https://python-docs.synapse.org/en/stable/
Admin
The Synapse Python client is a package that provides an interface to Synapse, a collaborative...
Tokens:2,925,048
Snippets:20,430
Trust Score:9.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### Start and prompt multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/agent?q=

This example demonstrates how to manage multiple sessions with an agent. It shows how to start a new session, send a prompt to it, and then start another session and send a prompt to that specific session, highlighting how the `current_session` is updated.

```APIDOC
## Start and prompt multiple sessions

Here, we connect to a custom agent and start one session with the prompt "Hello". In the background, this first session is being set as the current session and future prompts will be sent to this session by default. If we want to send a prompt to a different session, we can do so by starting it and calling prompt again, but with our new session as an argument. We now have two sessions, both stored in the `my_agent.sessions` dictionary. After the second prompt, `my_second_session` is now the current session.

```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Starting and Prompting Multiple Sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent

This example illustrates how to manage and interact with multiple agent sessions. It demonstrates starting a new session, prompting it, starting another session, and then prompting the second session, showing how the `session` parameter can be used to direct prompts.

```APIDOC
## prompt_async `async` with multiple sessions

### Description
Allows for managing and interacting with multiple agent sessions within the same agent instance. New sessions can be started, and prompts can be directed to specific sessions using the `session` parameter.

### Method Signature
`prompt_async(prompt: str, enable_trace: bool = False, print_response: bool = False, session: Optional[AgentSession] = None, newer_than: Optional[int] = None, *, timeout: int = 120, synapse_client: Optional[Synapse] = None) -> AgentPrompt`

### Parameters
(See general `prompt_async` parameters above. The `session` parameter is crucial here for directing prompts to specific sessions.)

### Request Example
```python
import asyncio
from synapseclient import Synapse
from synapseclient.models.agent import Agent

syn = Synapse()
syn.login()

async def main():
    my_agent = Agent(registration_id="foo").get() # Assuming .get() retrieves an existing agent or initializes one
    await my_agent.prompt_async(
        prompt="Hello",
        enable_trace=True,
        print_response=True,
    )

    my_second_session = await my_agent.start_session_async()
    await my_agent.prompt_async(
        prompt="Hello again",
        enable_trace=True,
        print_response=True,
        session=my_second_session,
    )

asyncio.run(main())
```

### Response
#### Success Response (200)
Returns an `AgentPrompt` object containing the agent's response for the specified session.
```

--------------------------------

### Initialize Synapse Client and Get Project

Source: https://python-docs.synapse.org/en/stable/tutorials/python/wiki

Sets up the Synapse client and retrieves a project object. Ensure you have completed installation and authentication.

```python
import os

from synapseclient import Synapse
from synapseclient.models import (
    Project,
    WikiHeader,
    WikiHistorySnapshot,
    WikiOrderHint,
    WikiPage,
)

syn = Synapse()
syn.login()

# Get the project
project = Project(name="My uniquely named project about Alzheimer's Disease").get()

```

--------------------------------

### Advanced Example: Start and Prompt Multiple Sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent?q=

Demonstrates managing multiple sessions with an agent, including starting new sessions and directing prompts to specific sessions.

```APIDOC
## Advanced Example: Start and prompt multiple sessions

Here, we connect to a custom agent and start one session with the prompt "Hello".
In the background, this first session is being set as the current session
and future prompts will be sent to this session by default. If we want to send a
prompt to a different session, we can do so by starting it and calling prompt again,
but with our new session as an argument. We now have two sessions, both stored in the
`my_agent.sessions` dictionary. After the second prompt, `my_second_session` is now
the current session.

```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Start and prompt multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent?q=

This example illustrates how to manage and interact with multiple sessions for an agent. It shows starting a new session and sending prompts to specific sessions.

```APIDOC
## Start and prompt multiple sessions

This example illustrates how to manage and interact with multiple sessions for an agent. It shows starting a new session and sending prompts to specific sessions.

```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Start and prompt multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent

This advanced example shows how to manage multiple sessions with an agent. It demonstrates starting a new session, sending a prompt to the default session, and then sending a prompt to a specifically chosen session.

```APIDOC
## Start and prompt multiple sessions

### Description
This advanced example shows how to manage multiple sessions with an agent. It demonstrates starting a new session, sending a prompt to the default session, and then sending a prompt to a specifically chosen session.

### Method
```python
Agent(registration_id='foo').get().prompt()
Agent().start_session().prompt(session=...)
```

### Parameters
#### Initialization Parameters
- **registration_id** (str) - Required - The ID number of the agent assigned by Synapse.

#### Prompt Parameters
- **prompt** (str) - Required - The message to send to the agent.
- **enable_trace** (bool) - Optional - Whether to enable tracing for the prompt.
- **print_response** (bool) - Optional - Whether to print the agent's response.
- **session** (AgentSession) - Optional - The specific session to send the prompt to. If not provided, the current session is used.

### Request Example
```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Starting and prompting multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent?q=

This advanced example demonstrates how to manage and interact with multiple agent sessions concurrently. It shows how to start a new session, prompt it, and then switch to another session for subsequent prompts.

```APIDOC
## prompt_async `async` with multiple sessions

### Description
This example illustrates managing multiple concurrent sessions with an agent. It shows how to initiate a new session, send a prompt to it, and then start and prompt a second session, which becomes the new current session.

### Parameters
- **prompt** (str) - Required - The prompt to send to the agent.
- **enable_trace** (bool) - Optional - Whether to enable tracing for the prompt.
- **print_response** (bool) - Optional - Whether to print the agent's response to the console.
- **newer_than** (int) - Optional - Filters results to be newer than the specified timestamp (in milliseconds).
- **timeout** (int) - Optional - The timeout in seconds before raising a SynapseTimeoutError. Defaults to 120.
- **session** (Session) - Optional - The specific session to use for the prompt. If not provided, the agent's current session is used.
- **synapse_client** (Synapse) - Optional - The Synapse client instance to use. 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.

### Request Example
```python
import asyncio
from synapseclient import Synapse
from synapseclient.models.agent import Agent

syn = Synapse()
syn.login()

async def main():
    my_agent = Agent(registration_id="foo").get()
    await my_agent.prompt_async(
        prompt="Hello",
        enable_trace=True,
        print_response=True,
    )

    my_second_session = await my_agent.start_session_async()
    await my_agent.prompt_async(
        prompt="Hello again",
        enable_trace=True,
        print_response=True,
        session=my_second_session,
    )

asyncio.run(main())
```
```

--------------------------------

### Start and prompt multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/agent

This advanced example demonstrates managing multiple sessions with an agent. It shows how to start a new session, send prompts to the current session, and explicitly send prompts to a different session.

```APIDOC
## Start and prompt multiple sessions

### Description
This advanced example demonstrates managing multiple sessions with an agent. It shows how to start a new session, send prompts to the current session, and explicitly send prompts to a different session.

### Method
```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Start and prompt multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/agent?q=

This advanced example demonstrates how to manage multiple sessions with a custom agent. It shows starting a new session, sending prompts to different sessions, and how the current session is updated.

```APIDOC
## Start and prompt multiple sessions

### Description
Here, we connect to a custom agent and start one session with the prompt "Hello".
In the background, this first session is being set as the current session
and future prompts will be sent to this session by default. If we want to send a
prompt to a different session, we can do so by starting it and calling prompt again,
but with our new session as an argument. We now have two sessions, both stored in the
`my_agent.sessions` dictionary. After the second prompt, `my_second_session` is now
the current session.

### Method
```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Start and prompt multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/agent

This example demonstrates how to manage and interact with multiple sessions for a given agent. It shows how to start a new session, send prompts to the current session by default, and send prompts to a specific session by passing it as an argument to the `prompt()` method.

```APIDOC
## Start and prompt multiple sessions

This example demonstrates how to manage and interact with multiple sessions for a given agent. It shows how to start a new session, send prompts to the current session by default, and send prompts to a specific session by passing it as an argument to the `prompt()` method.

```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Start and prompt multiple sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent

This example illustrates how to manage and interact with multiple chat sessions for a given agent. It shows starting a new session and sending prompts to specific sessions.

```APIDOC
## Start and prompt multiple sessions

### Description
This example illustrates how to manage and interact with multiple chat sessions for a given agent. It shows starting a new session and sending prompts to specific sessions.

### Method
```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Starting and Prompting Multiple Sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/agent?q=

This example demonstrates how to manage and prompt multiple sessions with a custom agent.

```APIDOC
## Advanced Example: Start and Prompt Multiple Sessions

### Description
This example shows how to connect to a custom agent, start multiple sessions, and prompt them. The `start_session()` method creates a new session, and subsequent prompts can be directed to specific sessions using the `session` argument. The `sessions` dictionary stores all active sessions.

### Method
`agent.start_session()` and `agent.prompt()`

### Parameters for `start_session()`
None

### Parameters for `prompt()`
- **prompt** (string) - Required - The query to send to the agent.
- **enable_trace** (boolean) - Optional - Whether to enable tracing for the prompt.
- **print_response** (boolean) - Optional - Whether to print the agent's response.
- **session** (object) - Optional - The specific session object to send the prompt to. If not provided, the prompt is sent to the current session.

### Request Example
```python
from synapseclient import Synapse
from synapseclient.models.agent import Agent

syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

# Start and prompt the first session
my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

# Start a second session and prompt it
my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```
```

--------------------------------

### Starting and Prompting Multiple Sessions

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent?q=

This example demonstrates how to manage and interact with multiple agent sessions concurrently.

```APIDOC
## prompt_async `async` with multiple sessions

### Description
Allows starting multiple agent sessions and directing prompts to specific sessions.

### Method Signature
`async prompt_async(prompt: str, enable_trace: bool = False, print_response: bool = False, session: Optional[AgentSession] = None, newer_than: Optional[int] = None, *, timeout: int = 120, synapse_client: Optional[Synapse] = None) -> AgentPrompt`

### Parameters
(See general `prompt_async` parameters above. The `session` parameter is key here for directing prompts.)

### Request Example
```python
import asyncio
from synapseclient import Synapse
from synapseclient.models.agent import Agent

syn = Synapse()
syn.login()

async def main():
    my_agent = Agent(registration_id="foo").get()
    await my_agent.prompt_async(
        prompt="Hello",
        enable_trace=True,
        print_response=True,
    )

    my_second_session = await my_agent.start_session_async()
    await my_agent.prompt_async(
        prompt="Hello again",
        enable_trace=True,
        print_response=True,
        session=my_second_session,
    )

asyncio.run(main())
```

### Response
#### Success Response (200)
- **AgentPrompt** (object) - The response from the agent for the specified session.
```

--------------------------------

### Install Synapse Client with Pip

Source: https://python-docs.synapse.org/en/stable/tutorials/installation?q=

Installs or upgrades the synapseclient package using pip. This is the quickest way to get started.

```bash
pip install --upgrade synapseclient
```

--------------------------------

### Initialize Synapse Client and Project

Source: https://python-docs.synapse.org/en/stable/tutorials/python/table

Sets up the Synapse client and retrieves a project. Ensure you have completed the Project tutorial and are logged into Synapse.

```python
import synapseclient
from synapseclient.models import Column, Project, query, SchemaStorageStrategy, Table

syn = synapseclient.Synapse()
syn.login()

project = Project(name="My uniquely named project about Alzheimer's Disease").get()

```

--------------------------------

### Full Example: Bind Schema and Get Derived Keys

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/folder?q=

A comprehensive example showing the setup required to bind a JSON schema with derived annotations enabled to a folder and a file, and then retrieve the derived keys. This includes creating organizations, schemas, folders, and files.

```python
from synapseclient import Synapse
from synapseclient.models import File, Folder

syn = Synapse()
syn.login()

# Define Project and JSON schema info
PROJECT_NAME = "test_json_schema_project"  # replace with your project name
FILE_PATH = "~/Sample.txt"  # replace with your test file path

PROJECT_ID = syn.findEntityId(name=PROJECT_NAME)
ORG_NAME = "UniqueOrg"  # replace with your organization name
DERIVED_TEST_SCHEMA_NAME = "myTestDerivedSchema"  # replace with your derived schema name
FOLDER_NAME = "test_script_folder"
VERSION = "0.0.1"
SCHEMA_URI = f"{ORG_NAME}-{DERIVED_TEST_SCHEMA_NAME}-{VERSION}"

# Create organization (if not already created)
js = syn.service("json_schema")
all_orgs = js.list_organizations()
for org in all_orgs:
    if org["name"] == ORG_NAME:
        print(f"Organization {ORG_NAME} already exists: {org}")
        break
else:
    print(f"Creating organization {ORG_NAME}.")
    created_organization = js.create_organization(ORG_NAME)
    print(f"Created organization: {created_organization}")

my_test_org = js.JsonSchemaOrganization(ORG_NAME)
test_schema = my_test_org.get_json_schema(DERIVED_TEST_SCHEMA_NAME)

if not test_schema:
    # Create the schema (if not already created)
    schema_definition = {
        "$id": "mySchema",
        "type": "object",
        "properties": {
            "foo": {"type": "string"},
            "baz": {"type": "string", "const": "example_value"},  # Example constant for derived annotation
            "bar": {"type": "integer"},
        },
        "required": ["foo"]
    }
    test_schema = my_test_org.create_json_schema(schema_definition, DERIVED_TEST_SCHEMA_NAME, VERSION)
    print(f"Created new derived schema: {DERIVED_TEST_SCHEMA_NAME}")

# Create a test folder
test_folder = Folder(name=FOLDER_NAME, parent_id=PROJECT_ID)
test_folder.store()
print(f"Created test folder: {FOLDER_NAME}")

# Bind JSON schema to the folder
bound_schema = test_folder.bind_schema(
    json_schema_uri=SCHEMA_URI,
    enable_derived_annotations=True
)
print(f"Bound schema to folder with derived annotations: {bound_schema}")

# Create and bind schema to a file
example_file = File(
    path=FILE_PATH,  # Replace with your test file path
    parent_id=test_folder.id,
).store()

bound_schema_file = example_file.bind_schema(
    json_schema_uri=SCHEMA_URI,
    enable_derived_annotations=True
)
print(f"Bound schema to file with derived annotations: {bound_schema_file}")

# Get the derived keys from the bound schema of the folder
test_folder.annotations = {"foo": "test_value_new", "bar": 42}  # Example annotations
test_folder.store()
print("Added annotations to folder and stored")

derived_keys = test_folder.get_schema_derived_keys()
print(f"Derived keys from folder: {derived_keys}")

# Get the derived keys from the bound schema of the file
example_file.annotations = {"foo": "test_value_new", "bar": 43}  # Example annotations
example_file.store()
print("Added annotations to file and stored")

derived_keys_file = example_file.get_schema_derived_keys()
print(f"Derived keys from file: {derived_keys_file}")
```

--------------------------------

### Initialize Synapse Client and Project

Source: https://python-docs.synapse.org/en/stable/tutorials/python/table?q=

Sets up the Synapse client and retrieves a project. Ensure you are logged in to Synapse.

```python
import synapseclient
from synapseclient.models import Column, Project, query, SchemaStorageStrategy, Table

syn = synapseclient.Synapse()
syn.login()

project = Project(name="My uniquely named project about Alzheimer's Disease").get()
```

--------------------------------

### Asynchronous Start Agent Session

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/agent

Provides an example of asynchronously starting an agent session and sending a prompt.

```APIDOC
## Asynchronous Start Agent Session

### Description
Asynchronously starts a new agent session and sends an initial prompt to the agent.

### Method
`await AgentSession(agent_registration_id="foo").start_async()`

### Parameters
- `agent_registration_id` (str): The registration ID of the agent.
- `synapse_client` (Synapse, optional): An optional Synapse client instance.

### Request Example
```python
import asyncio
from synapseclient import Synapse
from synapseclient.models.agent import AgentSession

syn = Synapse()
syn.login()

async def main():
    my_session = await AgentSession(agent_registration_id="foo").start_async()
    await my_session.prompt_async(
        prompt="Hello",
        enable_trace=True,
        print_response=True,
    )

asyncio.run(main())
```

### Response
- The `start_async()` method returns a coroutine that resolves to the initiated `AgentSession` object.
- The `prompt_async()` method returns a coroutine that processes the prompt and prints the response if `print_response` is True.
```

--------------------------------

### Set Up Synapse Python Client

Source: https://python-docs.synapse.org/en/stable/tutorials/python/json_schema

Initializes the Synapse client and logs in. Ensure you have completed the Project tutorial for prerequisites.

```python
import time
from pprint import pprint

import synapseclient
from synapseclient.core.utils import make_bogus_data_file
from synapseclient.models import File, Folder, JSONSchema, Project, SchemaOrganization

# 1. Set up Synapse Python client
syn = synapseclient.Synapse()
syn.login()
```

--------------------------------

### Get Wiki Page Example

Source: https://python-docs.synapse.org/en/stable/reference/wiki?q=

Example demonstrating how to retrieve a wiki page from Synapse using the `get_async` method.

```python
            wiki_page = await WikiPage(owner_id=project.id, id=wiki_page.id).get_async()
            print(wiki_page)
```

--------------------------------

### Get ACL Permissions for Public on a File (Deprecated)

Source: https://python-docs.synapse.org/en/stable/reference/client?q=

This is a deprecated method for getting ACL permissions. It is recommended to use the `get_acl` method on dataclass models instead. This example shows how to get permissions for the public on a file.

```python
permissions = syn.get_acl("syn123")
```

--------------------------------

### Set up and get Synapse project

Source: https://python-docs.synapse.org/en/stable/tutorials/python/sharing_settings?q=

Initializes the Synapse client and retrieves or creates a project for the tutorial. Ensure PRINCIPAL_ID is set to a valid Synapse user or team ID before running.

```python
import synapseclient
from synapseclient.models import Folder, Project

# REQUIRED: Set this to the Synapse user ID or team ID you want to grant permissions to
# Do NOT leave this as None - the script will not work properly
PRINCIPAL_ID = None  # Replace with actual user/team ID

if PRINCIPAL_ID is None:
    raise ValueError(
        "You must set PRINCIPAL_ID to a valid Synapse user ID or team ID before running this script. "
        "Examples: ###### (user ID), 273948 (authenticated users), 273949 (public)"
    )

syn = synapseclient.login()

# Step 1: Get or create a project for this tutorial
print("=== Step 1: Getting project ===")
project = Project(name="My uniquely named project about Alzheimer's Disease").get()
```

--------------------------------

### Get ACL Permissions for a User on a File (Deprecated)

Source: https://python-docs.synapse.org/en/stable/reference/client?q=

This is a deprecated method for getting ACL permissions. It is recommended to use the `get_acl` method on dataclass models instead. This example shows how to get permissions for a specific user on a file.

```python
permissions = syn.get_acl("syn123", principal_id="12345")
```

--------------------------------

### Full Example: Setting up and Validating Entities

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/curator?q=

This comprehensive example sets up a Synapse project, organization, JSON schema, folder, and file. It then binds the schema to the folder and file, adds annotations, and performs validation for both. This requires Synapse login and pre-existing project.

```python
from synapseclient import Synapse
from synapseclient.models import File, Folder
import time

syn = Synapse()
syn.login()

# Define Project and JSON schema info
PROJECT_NAME = "test_json_schema_project"  # replace with your project name
FILE_PATH = "~/Sample.txt"  # replace with your test file path

PROJECT_ID = syn.findEntityId(name=PROJECT_NAME)
ORG_NAME = "UniqueOrg"  # replace with your organization name
SCHEMA_NAME = "myTestSchema"  # replace with your schema name
FOLDER_NAME = "test_script_folder"
VERSION = "0.0.1"
SCHEMA_URI = f"{ORG_NAME}-{SCHEMA_NAME}-{VERSION}"

# Create organization (if not already created)
js = syn.service("json_schema")
all_orgs = js.list_organizations()
for org in all_orgs:
    if org["name"] == ORG_NAME:
        print(f"Organization {ORG_NAME} already exists: {org}")
        break
else:
    print(f"Creating organization {ORG_NAME}.")
    created_organization = js.create_organization(ORG_NAME)
    print(f"Created organization: {created_organization}")

my_test_org = js.JsonSchemaOrganization(ORG_NAME)
test_schema = my_test_org.get_json_schema(SCHEMA_NAME)

if not test_schema:
    # Create the schema (if not already created)
    schema_definition = {
        "$id": "mySchema",
        "type": "object",
        "properties": {
            "foo": {"type": "string"},
            "bar": {"type": "integer"},
        },
        "required": ["foo"]
    }
    test_schema = my_test_org.create_json_schema(schema_definition, SCHEMA_NAME, VERSION)
    print(f"Created new schema: {SCHEMA_NAME}")

# Create a test folder
test_folder = Folder(name=FOLDER_NAME, parent_id=PROJECT_ID)
test_folder.store()
print(f"Created test folder: {FOLDER_NAME}")

# Bind JSON schema to the folder
bound_schema = test_folder.bind_schema(
    json_schema_uri=SCHEMA_URI,
    enable_derived_annotations=True
)
print(f"Bound schema to folder: {bound_schema}")

# Create and bind schema to a file
example_file = File(
    path=FILE_PATH,  # Replace with your test file path
    parent_id=test_folder.id,
).store()

bound_schema_file = example_file.bind_schema(
    json_schema_uri=SCHEMA_URI,
    enable_derived_annotations=True
)
print(f"Bound schema to file: {bound_schema_file}")

# Validate the folder entity against the bound schema
test_folder.annotations = {"foo": "test_value", "bar": 42}  # Example annotations
test_folder.store()
print("Added annotations to folder and stored")
time.sleep(2)  # Allow time for processing

validation_response = test_folder.validate_schema()
print(f"Folder validation response: {validation_response}")

# Validate the file entity against the bound schema
example_file.annotations = {"foo": "test_value", "bar": 43}  # Example annotations
example_file.store()
print("Added annotations to file and stored")

validation_response_file = example_file.validate_schema()
print(f"File validation response: {validation_response_file}")
```

--------------------------------

### Synapse Storage Migration Setup

Source: https://python-docs.synapse.org/en/stable/guides/data_storage

Initializes the Synapse client and sets up paths for storage migration. Ensure you are logged in to Synapse.

```python
import os
import synapseutils
import synapseclient

my_synapse_project_or_folder_to_migrate = "syn123"

external_bucket_name = "my-external-synapse-bucket"
external_bucket_base_key = "path/within/bucket/"

my_user_id = "1234"

# a path on disk where this utility can create a sqlite database to store its index.
# nothing needs to exist at this path, but it must be a valid path on a volume with sufficient
# disk space to store a meta data listing of all the contents in the indexed entity.
# a rough rule of thumb is 100kB per 1000 entities indexed.
db_path = os.path.expanduser(
    f"~/synapseMigration/{my_synapse_project_or_folder_to_migrate}_my.db"
)

syn = synapseclient.Synapse()

# Log-in with ~.synapseConfig `authToken`
syn.login()

```

--------------------------------

### Initialize Synapse and Get Project

Source: https://python-docs.synapse.org/en/stable/tutorials/python/wiki

Sets up the Synapse client connection and retrieves a project object. This is a prerequisite for most wiki operations.

```python
import os

from synapseclient import Synapse
from synapseclient.models import (
    Project,
    WikiHeader,
    WikiHistorySnapshot,
    WikiOrderHint,
    WikiPage,
)

syn = Synapse()
syn.login()

# Get the project
project = Project(name="My uniquely named project about Alzheimer's Disease").get()
```

--------------------------------

### Initialize Synapse Client and Set Up Project Variables

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/project

Set up the Synapse client and define necessary variables for project and schema operations. This includes logging into Synapse, specifying project and file paths, and defining schema-related information like organization name, schema name, and version.

```python
import asyncio
from synapseclient import Synapse
from synapseclient.models import File, Folder

syn = Synapse()
syn.login()

# Define Project and JSON schema info
PROJECT_NAME = "test_json_schema_project"  # replace with your project name
FILE_PATH = "~/Sample.txt"  # replace with your test file path

PROJECT_ID = syn.findEntityId(name=PROJECT_NAME)
ORG_NAME = "UniqueOrg"  # replace with your organization name
SCHEMA_NAME = "myTestSchema"  # replace with your schema name
FOLDER_NAME = "test_script_folder"
VERSION = "0.0.1"
SCHEMA_URI = f"{ORG_NAME}-{SCHEMA_NAME}-{VERSION}"

```

--------------------------------

### Example: Get Derived Annotation Keys from Schemas

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/curator?q=

This example demonstrates retrieving derived annotation keys from schemas with constant values. Ensure you replace placeholder variables with your project-specific information.

```python
from synapseclient import Synapse
from synapseclient.models import File, Folder

syn = Synapse()
syn.login()

# Define Project and JSON schema info
PROJECT_NAME = "test_json_schema_project"  # replace with your project name
FILE_PATH = "~/Sample.txt"  # replace with your test file path

PROJECT_ID = syn.findEntityId(name=PROJECT_NAME)
ORG_NAME = "UniqueOrg"  # replace with your organization name
DERIVED_TEST_SCHEMA_NAME = "myTestDerivedSchema"  # replace with your derived schema name
FOLDER_NAME = "test_script_folder"
VERSION = "0.0.1"
SCHEMA_URI = f"{ORG_NAME}-{DERIVED_TEST_SCHEMA_NAME}-{VERSION}"

# Create organization (if not already created)
js = syn.service("json_schema")
all_orgs = js.list_organizations()
for org in all_orgs:
    if org["name"] == ORG_NAME:
        print(f"Organization {ORG_NAME} already exists: {org}")
        break
else:
    print(f"Creating organization {ORG_NAME}.")
    created_organization = js.create_organization(ORG_NAME)
    print(f"Created organization: {created_organization}")

my_test_org = js.JsonSchemaOrganization(ORG_NAME)
test_schema = my_test_org.get_json_schema(DERIVED_TEST_SCHEMA_NAME)

if not test_schema:
    # Create the schema (if not already created)
    schema_definition = {
        "$id": "mySchema",
        "type": "object",
        "properties": {
            "foo": {"type": "string"},
            "baz": {"type": "string", "const": "example_value"},  # Example constant for derived annotation
            "bar": {"type": "integer"},
        },
        "required": ["foo"]
    }
    test_schema = my_test_org.create_json_schema(schema_definition, DERIVED_TEST_SCHEMA_NAME, VERSION)
    print(f"Created new derived schema: {DERIVED_TEST_SCHEMA_NAME}")

# Create a test folder
test_folder = Folder(name=FOLDER_NAME, parent_id=PROJECT_ID)
test_folder.store()
print(f"Created test folder: {FOLDER_NAME}")

# Bind JSON schema to the folder
bound_schema = test_folder.bind_schema(
    json_schema_uri=SCHEMA_URI,
    enable_derived_annotations=True
)
print(f"Bound schema to folder with derived annotations: {bound_schema}")

# Create and bind schema to a file
example_file = File(
    path=FILE_PATH,  # Replace with your test file path
    parent_id=test_folder.id,
).store()

bound_schema_file = example_file.bind_schema(
    json_schema_uri=SCHEMA_URI,
    enable_derived_annotations=True
)
print(f"Bound schema to file with derived annotations: {bound_schema_file}")

# Get the derived keys from the bound schema of the folder
test_folder.annotations = {"foo": "test_value_new", "bar": 42}  # Example annotations
test_folder.store()
print("Added annotations to folder and stored")

derived_keys = test_folder.get_schema_derived_keys()
print(f"Derived keys from folder: {derived_keys}")

```

--------------------------------

### Synapse Python Client Initialization and Setup

Source: https://python-docs.synapse.org/en/stable/tutorials/python/virtualtable

Initializes the Synapse client, logs in, retrieves a project, and creates two initial tables with columns and data. This serves as the setup for creating virtual tables.

```python

"""Here is where you'll find the code for the VirtualTable tutorial."""

import pandas as pd

from synapseclient import Synapse
from synapseclient.models import Column, ColumnType, Project, Table, VirtualTable

# Initialize Synapse client
syn = Synapse()
syn.login()

# Get the project where we want to create the virtual table
project = Project(name="My uniquely named project about Alzheimer's Disease").get()
project_id = project.id
print(f"Got project with ID: {project_id}")

# Create the first table with some columns and rows
table1_columns = [
    Column(name="sample_id", column_type=ColumnType.STRING),
    Column(name="patient_id", column_type=ColumnType.STRING),
    Column(name="age", column_type=ColumnType.INTEGER),
    Column(name="diagnosis", column_type=ColumnType.STRING),
]

table1 = Table(
    name="Patient Demographics",
    parent_id=project_id,
    columns=table1_columns,
)
table1 = table1.store()
print(f"Created table 1 with ID: {table1.id}")

# Add rows to the first table
data1 = pd.DataFrame(
    [
        {"sample_id": "S1", "patient_id": "P1", "age": 70, "diagnosis": "Alzheimer's"},
        {"sample_id": "S2", "patient_id": "P2", "age": 65, "diagnosis": "Healthy"},
        {"sample_id": "S3", "patient_id": "P3", "age": 72, "diagnosis": "Alzheimer's"},
        {"sample_id": "S4", "patient_id": "P4", "age": 68, "diagnosis": "Healthy"},
        {"sample_id": "S5", "patient_id": "P5", "age": 75, "diagnosis": "Alzheimer's"},
        {"sample_id": "S6", "patient_id": "P6", "age": 80, "diagnosis": "Healthy"},
    ]
)
table1.upsert_rows(values=data1, primary_keys=["sample_id"])

# Create the second table with some columns and rows
table2_columns = [
    Column(name="sample_id", column_type=ColumnType.STRING),
    Column(name="gene", column_type=ColumnType.STRING),
    Column(name="expression_level", column_type=ColumnType.DOUBLE),
]

table2 = Table(
    name="Gene Expression Data",
    parent_id=project_id,
    columns=table2_columns,
)
table2 = table2.store()
print(f"Created table 2 with ID: {table2.id}")


```

--------------------------------

### Start an Agent Session Asynchronously

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent?q=

This snippet demonstrates how to start a new agent session asynchronously using the `start_async` method. It shows how to initialize an AgentSession with a specific agent registration ID and then initiate the session. It also includes an example of sending a prompt to the agent after the session has started.

```APIDOC
## start_async

### Description
Starts an agent session asynchronously.

### Method
`async def start_async(self, *, synapse_client: Optional[Synapse] = None) -> "AgentSession"`

### Parameters
- `synapse_client` (Synapse, optional): The Synapse client instance. If not provided, it uses the last created instance from the Synapse class constructor if client caching is enabled.

### Returns
- `AgentSession`: The newly started AgentSession object.

### Example
```python
import asyncio
from synapseclient import Synapse
from synapseclient.models.agent import AgentSession

syn = Synapse()
syn.login()

async def main():
    my_session = await AgentSession(agent_registration_id="foo").start_async()
    await my_session.prompt_async(
        prompt="Hello",
        enable_trace=True,
        print_response=True,
    )

asyncio.run(main())
```
```

--------------------------------

### Initialize Synapse and Login

Source: https://python-docs.synapse.org/en/stable/tutorials/python/wiki?q=

Sets up the Synapse client and logs in. This is a prerequisite for interacting with Synapse resources.

```python
syn = Synapse()
syn.login()
```

--------------------------------

### Set up Synapse Client and Define Schema Details

Source: https://python-docs.synapse.org/en/stable/reference/experimental/mixins/json_schema

This code sets up the Synapse client, logs in, and defines variables for project, file path, organization, schema name, folder name, version, and schema URI. Replace placeholder values with your specific details.

```python
import asyncio
import time
from synapseclient import Synapse
from synapseclient.models import File, Folder

syn = Synapse()
syn.login()

# Define Project and JSON schema info
PROJECT_NAME = "test_json_schema_project"  # replace with your project name
FILE_PATH = "~/Sample.txt"  # replace with your test file path

PROJECT_ID = syn.findEntityId(name=PROJECT_NAME)
ORG_NAME = "UniqueOrg"  # replace with your organization name
SCHEMA_NAME = "myTestSchema"  # replace with your schema name
FOLDER_NAME = "test_script_folder"
VERSION = "0.0.1"
SCHEMA_URI = f"{ORG_NAME}-{SCHEMA_NAME}-{VERSION}"

```

--------------------------------

### Initialize Synapse Client and Set Up Paths

Source: https://python-docs.synapse.org/en/stable/tutorials/python/upload_data_in_bulk

Initializes the Synapse client and defines constants for project directory and manifest file paths. Ensure you are logged into Synapse before running.

```python
"""
Here is where you'll find the code for the uploading data in bulk tutorial.
"""

import os

import synapseclient
import synapseutils

syn = synapseclient.Synapse()
syn.login()

# Create some constants to store the paths to the data
DIRECTORY_FOR_MY_PROJECT = os.path.expanduser(os.path.join("~", "my_ad_project"))
PATH_TO_MANIFEST_FILE = os.path.expanduser(os.path.join("~", "manifest-for-upload.tsv"))

```

--------------------------------

### Creating a Project

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/project

Example demonstrating how to create a new Synapse project.

```APIDOC
## Example: Creating a project

```python
# Assuming you have a Synapse client initialized
# from synapseclient import Synapse
# syn = Synapse()

# Create a new project
new_project = syn.create_project(name='My New Project', description='This is a test project.')

print(f"Project created with ID: {new_project.id}")
```
```

--------------------------------

### Authenticate and Get Project ID

Source: https://python-docs.synapse.org/en/stable/tutorials/python/dataset

Authenticates with Synapse and retrieves the ID of your specified project. Ensure you have pandas installed.

```python
import pandas as pd

from synapseclient import Synapse
from synapseclient.models import (
    Column,
    ColumnType,
    Dataset,
    EntityRef,
    File,
    Folder,
    Project,
)

# First, let's get the project that we want to create the dataset in
syn = Synapse()
syn.login()

project = Project(
    name="My uniquely named project about Alzheimer's Disease"  # Replace with your project name
).get()
project_id = project.id
print(f"My project ID is {project_id}")

```

--------------------------------

### Start and prompt multiple sessions with an agent

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent

This advanced example shows how to manage multiple sessions with a custom agent. You can start new sessions and direct prompts to specific sessions, with the latest session becoming the default for subsequent prompts.

```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)
```

--------------------------------

### Initialize Synapse Client and Create Tables

Source: https://python-docs.synapse.org/en/stable/tutorials/python/virtualtable?q=

Sets up the Synapse client, logs in, retrieves a project, and creates two tables with sample data. Ensure your project name is correctly specified. This code is a prerequisite for creating Virtual Tables.

```python
import pandas as pd

from synapseclient import Synapse
from synapseclient.models import Column, ColumnType, Project, Table, VirtualTable

# Initialize Synapse client
syn = Synapse()
syn.login()

# Get the project where we want to create the virtual table
project = Project(name="My uniquely named project about Alzheimer's Disease").get()
project_id = project.id
print(f"Got project with ID: {project_id}")

# Create the first table with some columns and rows
table1_columns = [
    Column(name="sample_id", column_type=ColumnType.STRING),
    Column(name="patient_id", column_type=ColumnType.STRING),
    Column(name="age", column_type=ColumnType.INTEGER),
    Column(name="diagnosis", column_type=ColumnType.STRING),
]

table1 = Table(
    name="Patient Demographics",
    parent_id=project_id,
    columns=table1_columns,
)
table1 = table1.store()
print(f"Created table 1 with ID: {table1.id}")

# Add rows to the first table
data1 = pd.DataFrame(
    [
        {"sample_id": "S1", "patient_id": "P1", "age": 70, "diagnosis": "Alzheimer's"},
        {"sample_id": "S2", "patient_id": "P2", "age": 65, "diagnosis": "Healthy"},
        {"sample_id": "S3", "patient_id": "P3", "age": 72, "diagnosis": "Alzheimer's"},
        {"sample_id": "S4", "patient_id": "P4", "age": 68, "diagnosis": "Healthy"},
        {"sample_id": "S5", "patient_id": "P5", "age": 75, "diagnosis": "Alzheimer's"},
        {"sample_id": "S6", "patient_id": "P6", "age": 80, "diagnosis": "Healthy"},
    ]
)
table1.upsert_rows(values=data1, primary_keys=["sample_id"])

# Create the second table with some columns and rows
table2_columns = [
    Column(name="sample_id", column_type=ColumnType.STRING),
    Column(name="gene", column_type=ColumnType.STRING),
    Column(name="expression_level", column_type=ColumnType.DOUBLE),
]

table2 = Table(
    name="Gene Expression Data",
    parent_id=project_id,
    columns=table2_columns,
)
table2 = table2.store()
print(f"Created table 2 with ID: {table2.id}")

# Add rows to the second table
data2 = pd.DataFrame(
    [
        {"sample_id": "S1", "gene": "APOE", "expression_level": 2.5},
        {"sample_id": "S2", "gene": "APP", "expression_level": 1.8},
        {"sample_id": "S3", "gene": "PSEN1", "expression_level": 3.2},
        {"sample_id": "S4", "gene": "MAPT", "expression_level": 2.1},
        {"sample_id": "S5", "gene": "APP", "expression_level": 3.5},
        {"sample_id": "S7", "gene": "PSEN2", "expression_level": 1.9},
    ]
)
table2.upsert_rows(values=data2, primary_keys=["sample_id"])

```

--------------------------------

### Example: Creating a project

Source: https://python-docs.synapse.org/en/stable/reference/experimental/sync/project

Illustrates how to create a new project in Synapse.

```APIDOC
## Example: Creating a project

### Description
This example demonstrates the process of creating a new project.

### Code
```python
# Assuming 'syn' is an authenticated Synapse client instance
new_project = Project(name='My New Project', description='This is a project for my data.')
stored_project = syn.store(new_project)
print(f"Created project with ID: {stored_project.id}")
```
```

--------------------------------

### Start and Prompt Multiple Sessions with an Agent

Source: https://python-docs.synapse.org/en/stable/reference/experimental/async/agent

Manage and interact with multiple chat sessions for a given agent. This example shows how to start a new session, send prompts to the default session, and then send prompts to a specifically chosen session.

```python
syn = Synapse()
syn.login()

my_agent = Agent(registration_id="foo").get()

my_agent.prompt(
    prompt="Hello",
    enable_trace=True,
    print_response=True,
)

my_second_session = my_agent.start_session()
my_agent.prompt(
    prompt="Hello again",
    enable_trace=True,
    print_response=True,
    session=my_second_session,
)

```

--------------------------------

### Deprecated `tableQuery` Method

Source: https://python-docs.synapse.org/en/stable/reference/client?q=

Provides examples for the deprecated `tableQuery` method, showing how to get results as a DataFrame or a CSV file.

```APIDOC
## Deprecated `tableQuery` Method

### Description
This method is deprecated and will be removed in a future version. Use the `query` or `query_async` functions instead. Examples show its usage for retrieving results as a DataFrame or a CSV file.

### Method
`syn.tableQuery()`

### Parameters
#### Query Parameters
- **query** (string) - Required - The SQL query string.
- **resultsAs** (string) - Optional - Specifies the format of the results. Can be 'rowset' or 'csv'.
- **downloadLocation** (string) - Optional - The directory to download CSV results to if `resultsAs` is 'csv'.

### Request Example
```python
from synapseclient import Synapse

syn = Synapse()
syn.login()

# Getting query results as a DataFrame
results = syn.tableQuery("SELECT * FROM syn12345")
df = results.asDataFrame()

# Getting query results as a CSV file
results = syn.tableQuery("SELECT * FROM syn12345", resultsAs="csv", downloadLocation="./my_data/")
```
```
Tokens:
Raw