Centralize session route and operation metadata constants

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

CONTRIBUTING.md

@@ -132,7 +132,9 @@ This runs lint, format checks, compile checks, tests, and package build.
   - `tests/test_pyproject_architecture_marker.py` (pytest marker registration enforcement),
   - `tests/test_readme_examples_listing.py` (README example-listing consistency enforcement),
   - `tests/test_schema_injection_helper_usage.py` (shared schema injection helper usage enforcement in payload builders),
+  - `tests/test_session_operation_metadata_usage.py` (session manager operation-metadata usage enforcement),
   - `tests/test_session_profile_update_helper_usage.py` (session profile-update parameter helper usage enforcement),
+  - `tests/test_session_route_constants_usage.py` (session manager route-constant usage enforcement),
   - `tests/test_session_upload_helper_usage.py` (session upload-input normalization helper usage enforcement),
   - `tests/test_start_and_wait_default_constants_usage.py` (shared start-and-wait default-constant usage enforcement),
   - `tests/test_start_job_context_helper_usage.py` (shared started-job context helper usage enforcement),

hyperbrowser/client/managers/async_manager/session.py

@@ -8,6 +8,20 @@
 )
 from ..session_profile_update_utils import resolve_update_profile_params
 from ..session_upload_utils import open_upload_files_from_input
+from ..session_operation_metadata import SESSION_OPERATION_METADATA
+from ..session_route_constants import (
+    SESSION_DOWNLOADS_URL_ROUTE_SUFFIX,
+    SESSION_EVENT_LOGS_ROUTE_SUFFIX,
+    SESSION_EXTEND_ROUTE_SUFFIX,
+    SESSION_RECORDING_ROUTE_SUFFIX,
+    SESSION_RECORDING_URL_ROUTE_SUFFIX,
+    SESSION_ROUTE_PREFIX,
+    SESSION_STOP_ROUTE_SUFFIX,
+    SESSION_UPDATE_ROUTE_SUFFIX,
+    SESSION_UPLOADS_ROUTE_SUFFIX,
+    SESSION_VIDEO_RECORDING_URL_ROUTE_SUFFIX,
+    SESSIONS_ROUTE_PATH,
+)
 from ..session_utils import (
     parse_session_recordings_response_data,
     parse_session_response_model,
@@ -31,6 +45,9 @@
 
 
 class SessionEventLogsManager:
+    _OPERATION_METADATA = SESSION_OPERATION_METADATA
+    _ROUTE_PREFIX = SESSION_ROUTE_PREFIX
+
     def __init__(self, client):
         self._client = client
 
@@ -45,18 +62,23 @@ async def list(
             error_message="Failed to serialize session event log params",
         )
         response = await self._client.transport.get(
-            self._client._build_url(f"/session/{session_id}/event-logs"),
+            self._client._build_url(
+                f"{self._ROUTE_PREFIX}/{session_id}{SESSION_EVENT_LOGS_ROUTE_SUFFIX}"
+            ),
             params=query_params,
         )
         return parse_session_response_model(
             response.data,
             model=SessionEventLogListResponse,
-            operation_name="session event logs",
+            operation_name=self._OPERATION_METADATA.event_logs_operation_name,
         )
 
 
 class SessionManager:
     _has_warned_update_profile_params_boolean_deprecated: bool = False
+    _OPERATION_METADATA = SESSION_OPERATION_METADATA
+    _ROUTE_PREFIX = SESSION_ROUTE_PREFIX
+    _LIST_ROUTE_PATH = SESSIONS_ROUTE_PATH
 
     def __init__(self, client):
         self._client = client
@@ -70,13 +92,13 @@ async def create(
             error_message="Failed to serialize session create params",
         )
         response = await self._client.transport.post(
-            self._client._build_url("/session"),
+            self._client._build_url(self._ROUTE_PREFIX),
             data=payload,
         )
         return parse_session_response_model(
             response.data,
             model=SessionDetail,
-            operation_name="session detail",
+            operation_name=self._OPERATION_METADATA.detail_operation_name,
         )
 
     async def get(
@@ -88,23 +110,23 @@ async def get(
             error_message="Failed to serialize session get params",
         )
         response = await self._client.transport.get(
-            self._client._build_url(f"/session/{id}"),
+            self._client._build_url(f"{self._ROUTE_PREFIX}/{id}"),
             params=query_params,
         )
         return parse_session_response_model(
             response.data,
             model=SessionDetail,
-            operation_name="session detail",
+            operation_name=self._OPERATION_METADATA.detail_operation_name,
         )
 
     async def stop(self, id: str) -> BasicResponse:
         response = await self._client.transport.put(
-            self._client._build_url(f"/session/{id}/stop")
+            self._client._build_url(f"{self._ROUTE_PREFIX}/{id}{SESSION_STOP_ROUTE_SUFFIX}")
         )
         return parse_session_response_model(
             response.data,
             model=BasicResponse,
-            operation_name="session stop",
+            operation_name=self._OPERATION_METADATA.stop_operation_name,
         )
 
     async def list(
@@ -116,77 +138,91 @@ async def list(
             error_message="Failed to serialize session list params",
         )
         response = await self._client.transport.get(
-            self._client._build_url("/sessions"),
+            self._client._build_url(self._LIST_ROUTE_PATH),
             params=query_params,
         )
         return parse_session_response_model(
             response.data,
             model=SessionListResponse,
-            operation_name="session list",
+            operation_name=self._OPERATION_METADATA.list_operation_name,
         )
 
     async def get_recording(self, id: str) -> List[SessionRecording]:
         response = await self._client.transport.get(
-            self._client._build_url(f"/session/{id}/recording"), None, True
+            self._client._build_url(
+                f"{self._ROUTE_PREFIX}/{id}{SESSION_RECORDING_ROUTE_SUFFIX}"
+            ),
+            None,
+            True,
         )
         return parse_session_recordings_response_data(response.data)
 
     async def get_recording_url(self, id: str) -> GetSessionRecordingUrlResponse:
         response = await self._client.transport.get(
-            self._client._build_url(f"/session/{id}/recording-url")
+            self._client._build_url(
+                f"{self._ROUTE_PREFIX}/{id}{SESSION_RECORDING_URL_ROUTE_SUFFIX}"
+            )
         )
         return parse_session_response_model(
             response.data,
             model=GetSessionRecordingUrlResponse,
-            operation_name="session recording url",
+            operation_name=self._OPERATION_METADATA.recording_url_operation_name,
         )
 
     async def get_video_recording_url(
         self, id: str
     ) -> GetSessionVideoRecordingUrlResponse:
         response = await self._client.transport.get(
-            self._client._build_url(f"/session/{id}/video-recording-url")
+            self._client._build_url(
+                f"{self._ROUTE_PREFIX}/{id}{SESSION_VIDEO_RECORDING_URL_ROUTE_SUFFIX}"
+            )
         )
         return parse_session_response_model(
             response.data,
             model=GetSessionVideoRecordingUrlResponse,
-            operation_name="session video recording url",
+            operation_name=self._OPERATION_METADATA.video_recording_url_operation_name,
         )
 
     async def get_downloads_url(self, id: str) -> GetSessionDownloadsUrlResponse:
         response = await self._client.transport.get(
-            self._client._build_url(f"/session/{id}/downloads-url")
+            self._client._build_url(
+                f"{self._ROUTE_PREFIX}/{id}{SESSION_DOWNLOADS_URL_ROUTE_SUFFIX}"
+            )
         )
         return parse_session_response_model(
             response.data,
             model=GetSessionDownloadsUrlResponse,
-            operation_name="session downloads url",
+            operation_name=self._OPERATION_METADATA.downloads_url_operation_name,
         )
 
     async def upload_file(
         self, id: str, file_input: Union[str, PathLike[str], IO]
     ) -> UploadFileResponse:
         with open_upload_files_from_input(file_input) as files:
             response = await self._client.transport.post(
-                self._client._build_url(f"/session/{id}/uploads"),
+                self._client._build_url(
+                    f"{self._ROUTE_PREFIX}/{id}{SESSION_UPLOADS_ROUTE_SUFFIX}"
+                ),
                 files=files,
             )
 
         return parse_session_response_model(
             response.data,
             model=UploadFileResponse,
-            operation_name="session upload file",
+            operation_name=self._OPERATION_METADATA.upload_file_operation_name,
         )
 
     async def extend_session(self, id: str, duration_minutes: int) -> BasicResponse:
         response = await self._client.transport.put(
-            self._client._build_url(f"/session/{id}/extend-session"),
+            self._client._build_url(
+                f"{self._ROUTE_PREFIX}/{id}{SESSION_EXTEND_ROUTE_SUFFIX}"
+            ),
             data={"durationMinutes": duration_minutes},
         )
         return parse_session_response_model(
             response.data,
             model=BasicResponse,
-            operation_name="session extend",
+            operation_name=self._OPERATION_METADATA.extend_operation_name,
         )
 
     @overload
@@ -218,7 +254,9 @@ async def update_profile_params(
         )
 
         response = await self._client.transport.put(
-            self._client._build_url(f"/session/{id}/update"),
+            self._client._build_url(
+                f"{self._ROUTE_PREFIX}/{id}{SESSION_UPDATE_ROUTE_SUFFIX}"
+            ),
             data={
                 "type": "profile",
                 "params": serialized_params,
@@ -227,7 +265,7 @@ async def update_profile_params(
         return parse_session_response_model(
             response.data,
             model=BasicResponse,
-            operation_name="session update profile",
+            operation_name=self._OPERATION_METADATA.update_profile_operation_name,
         )
 
     def _warn_update_profile_params_boolean_deprecated(self) -> None:

hyperbrowser/client/managers/session_operation_metadata.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SessionOperationMetadata:
+    event_logs_operation_name: str
+    detail_operation_name: str
+    stop_operation_name: str
+    list_operation_name: str
+    recording_url_operation_name: str
+    video_recording_url_operation_name: str
+    downloads_url_operation_name: str
+    upload_file_operation_name: str
+    extend_operation_name: str
+    update_profile_operation_name: str
+
+
+SESSION_OPERATION_METADATA = SessionOperationMetadata(
+    event_logs_operation_name="session event logs",
+    detail_operation_name="session detail",
+    stop_operation_name="session stop",
+    list_operation_name="session list",
+    recording_url_operation_name="session recording url",
+    video_recording_url_operation_name="session video recording url",
+    downloads_url_operation_name="session downloads url",
+    upload_file_operation_name="session upload file",
+    extend_operation_name="session extend",
+    update_profile_operation_name="session update profile",
+)

hyperbrowser/client/managers/session_route_constants.py

@@ -0,0 +1,12 @@
+SESSION_ROUTE_PREFIX = "/session"
+SESSIONS_ROUTE_PATH = "/sessions"
+
+SESSION_EVENT_LOGS_ROUTE_SUFFIX = "/event-logs"
+SESSION_STOP_ROUTE_SUFFIX = "/stop"
+SESSION_RECORDING_ROUTE_SUFFIX = "/recording"
+SESSION_RECORDING_URL_ROUTE_SUFFIX = "/recording-url"
+SESSION_VIDEO_RECORDING_URL_ROUTE_SUFFIX = "/video-recording-url"
+SESSION_DOWNLOADS_URL_ROUTE_SUFFIX = "/downloads-url"
+SESSION_UPLOADS_ROUTE_SUFFIX = "/uploads"
+SESSION_EXTEND_ROUTE_SUFFIX = "/extend-session"
+SESSION_UPDATE_ROUTE_SUFFIX = "/update"