Skip to content

Versions

Versions lets you create and manage snapshots of a CXAS app. Every time you publish significant changes, you can tag that state as a version — giving you a rollback point if something goes wrong, and a stable target for running evaluations against a known baseline.

You can also use Sessions to run conversations against a specific version by passing version_id to the constructor or to individual run() calls.

Quick Example

from cxas_scrapi import Versions

app_name = "projects/my-project/locations/us/apps/my-app-id"
versions = Versions(app_name=app_name)

# List all versions
all_versions = versions.list_versions()
for v in all_versions:
    print(v.display_name, v.name)

# Get a map of version display names to resource names
versions_map = versions.get_versions_map()
print(versions_map)

# Use a specific version in a session
from cxas_scrapi import Sessions
sessions = Sessions(app_name=app_name, version_id="v1-0-0")

Reference

Versions 

Versions(app_name, creds_path=None, creds_dict=None, creds=None, scope=None, **kwargs)

Bases: Apps

Core Class for managing AppVersion Resources.

Initializes the Versions client.

Source code in src/cxas_scrapi/core/versions.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
def __init__(
    self,
    app_name: str,
    creds_path: str | None = None,
    creds_dict: dict[str, str] | None = None,
    creds: Any = None,
    scope: list[str] | None = None,
    **kwargs,
):
    """Initializes the Versions client."""
    project_id = Common._get_project_id(app_name)
    location = Common._get_location(app_name)
    if not project_id or not location:
        raise ValueError(
            f"Invalid app_name format: {app_name}. "
            "Expected format: "
            "projects/<project>/locations/<location>/apps/<app>"
        )

    super().__init__(
        project_id=project_id,
        location=location,
        creds_path=creds_path,
        creds_dict=creds_dict,
        creds=creds,
        scope=scope,
        **kwargs,
    )
    self.resource_type = "versions"
    self.app_name = app_name

list_versions 

list_versions()

Lists versions within the app.

Source code in src/cxas_scrapi/core/versions.py 
59
60
61
62
63
def list_versions(self) -> list[types.AppVersion]:
    """Lists versions within the app."""
    request = types.ListAppVersionsRequest(parent=self.app_name)
    response = self.client.list_app_versions(request=request)
    return list(response)

get_versions_map 

get_versions_map(reverse=False)

Returns a map of version display names to full resource names.

Parameters:

Name Type Description Default
reverse bool

If True, map display_name -> name.

 False
Source code in src/cxas_scrapi/core/versions.py 
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def get_versions_map(self, reverse: bool = False) -> dict[str, str]:
    """Returns a map of version display names to full resource names.

    Args:
        reverse: If True, map display_name -> name.
    """
    versions = self.list_versions()
    versions_map: dict[str, str] = {}

    for version in versions:
        display_name = version.display_name
        name = version.name
        if display_name and name:
            if reverse:
                versions_map[display_name] = name
            else:
                versions_map[name] = display_name

    return versions_map

create_version 

create_version(display_name='', description='')

Creates a new version of the app.

Source code in src/cxas_scrapi/core/versions.py 
85
86
87
88
89
90
91
92
93
94
95
96
def create_version(
    self, display_name: str = "", description: str = ""
) -> types.AppVersion:
    """Creates a new version of the app."""
    app_version = types.AppVersion(
        display_name=display_name, description=description
    )
    request = types.CreateAppVersionRequest(
        parent=self.app_name, app_version=app_version
    )
    # Assuming generated client supports create_app_version natively
    return self.client.create_app_version(request=request)

get_version 

get_version(version_id)

Gets a specific version.

Source code in src/cxas_scrapi/core/versions.py 
 98
 99
100
101
102
103
def get_version(self, version_id: str) -> types.AppVersion:
    """Gets a specific version."""
    request = types.GetAppVersionRequest(
        name=f"{self.app_name}/versions/{version_id}"
    )
    return self.client.get_app_version(request=request)

delete_version 

delete_version(version_id)

Deletes a specific version.

Source code in src/cxas_scrapi/core/versions.py 
105
106
107
108
109
110
def delete_version(self, version_id: str) -> None:
    """Deletes a specific version."""
    request = types.DeleteAppVersionRequest(
        name=f"{self.app_name}/versions/{version_id}"
    )
    self.client.delete_app_version(request=request)

revert_version 

revert_version(version_id)

Reverts (Restores) a specific version.

Source code in src/cxas_scrapi/core/versions.py 
112
113
114
115
116
117
def revert_version(self, version_id: str) -> Any:
    """Reverts (Restores) a specific version."""
    request = types.RestoreAppVersionRequest(
        name=f"{self.app_name}/versions/{version_id}"
    )
    return self.client.restore_app_version(request=request)