recce-nightly 1.11.0.20250708__py3-none-any.whl → 1.12.0.20250709__py3-none-any.whl

recce/state.py

@@ -9,7 +9,7 @@ from base64 import b64encode
 from dataclasses import dataclass
 from datetime import datetime
 from hashlib import md5, sha256
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Literal, Optional, Tuple, Union
 from urllib.parse import urlencode
 
 import botocore.exceptions
@@ -17,6 +17,7 @@ from pydantic import BaseModel, Field
 
 from recce import get_version
 from recce.event import get_recce_api_token
+from recce.exceptions import RecceException
 from recce.git import current_branch
 from recce.models import CheckDAO
 from recce.models.types import Check, Run
@@ -136,7 +137,7 @@ class RecceState(BaseModel):
             if metadata.schema_version == "v0":
                 pass
             else:
-                raise Exception(f"Unsupported state file version: {metadata.schema_version}")
+                raise RecceException(f"Unsupported state file version: {metadata.schema_version}")
         return state
 
     @staticmethod
@@ -203,28 +204,50 @@ class RecceStateLoader:
         self.state_lock = threading.Lock()
         self.state_etag = None
         self.pr_info = None
+        self.catalog: Literal["github", "preview"] = "github"
+        self.share_id = None
 
         if self.cloud_mode:
-            if not self.cloud_options.get("token"):
-                raise Exception(RECCE_CLOUD_TOKEN_MISSING.error_message)
-            self.pr_info = fetch_pr_metadata(cloud=self.cloud_mode, github_token=self.cloud_options.get("token"))
-            if self.pr_info.id is None:
-                raise Exception("Cannot get the pull request information from GitHub.")
+            if self.cloud_options.get("github_token"):
+                self.catalog = "github"
+                self.pr_info = fetch_pr_metadata(
+                    cloud=self.cloud_mode, github_token=self.cloud_options.get("github_token")
+                )
+                if self.pr_info.id is None:
+                    raise RecceException("Cannot get the pull request information from GitHub.")
+            elif self.cloud_options.get("api_token"):
+                self.catalog = "preview"
+                self.share_id = self.cloud_options.get("share_id")
+            else:
+                raise RecceException(RECCE_CLOUD_TOKEN_MISSING.error_message)
 
         # Load the state
         self.load()
 
     def verify(self) -> bool:
         if self.cloud_mode:
-            if self.cloud_options.get("token") is None:
-                self.error_message = RECCE_CLOUD_TOKEN_MISSING.error_message
-                self.hint_message = RECCE_CLOUD_TOKEN_MISSING.hint_message
-                return False
-            if not self.cloud_options.get("host"):
-                if self.cloud_options.get("password") is None:
-                    self.error_message = RECCE_CLOUD_PASSWORD_MISSING.error_message
-                    self.hint_message = RECCE_CLOUD_PASSWORD_MISSING.hint_message
+            if self.catalog == "github":
+                if self.cloud_options.get("github_token") is None:
+                    self.error_message = RECCE_CLOUD_TOKEN_MISSING.error_message
+                    self.hint_message = RECCE_CLOUD_TOKEN_MISSING.hint_message
                     return False
+                if not self.cloud_options.get("host"):
+                    if self.cloud_options.get("password") is None:
+                        self.error_message = RECCE_CLOUD_PASSWORD_MISSING.error_message
+                        self.hint_message = RECCE_CLOUD_PASSWORD_MISSING.hint_message
+                        return False
+            elif self.catalog == "preview":
+                if self.cloud_options.get("api_token") is None:
+                    self.error_message = RECCE_API_TOKEN_MISSING.error_message
+                    self.hint_message = RECCE_API_TOKEN_MISSING.hint_message
+                    return False
+                if self.cloud_options.get("share_id") is None:
+                    self.error_message = "No share ID is provided for the preview catalog."
+                    self.hint_message = (
+                        'Please provide a share URL in the command argument with option "--share-url <share-url>"'
+                    )
+                    return False
+
         else:
             if self.review_mode is True and self.state_file is None:
                 self.error_message = "Recce can not launch without a state file."
@@ -233,6 +256,10 @@ class RecceStateLoader:
             pass
         return True
 
+    @property
+    def token(self):
+        return self.cloud_options.get("github_token") or self.cloud_options.get("api_token")
+
     @property
     def error_and_hint(self) -> (Union[str, None], Union[str, None]):
         return self.error_message, self.hint_message
@@ -348,8 +375,12 @@ class RecceStateLoader:
             RecceState: The state object.
             str: The etag of the state file.
         """
-        if (self.pr_info is None) or (self.pr_info.id is None) or (self.pr_info.repository is None):
-            raise Exception("Cannot get the pull request information from GitHub.")
+        if self.catalog == "github":
+            if (self.pr_info is None) or (self.pr_info.id is None) or (self.pr_info.repository is None):
+                raise RecceException("Cannot get the pull request information from GitHub.")
+        elif self.catalog == "preview":
+            if self.share_id is None:
+                raise RecceException("Cannot load the share state from Recce Cloud. No share ID is provided.")
 
         if self.cloud_options.get("host", "").startswith("s3://"):
             logger.debug("Fetching state from AWS S3 bucket...")
@@ -357,49 +388,60 @@ class RecceStateLoader:
         else:
             logger.debug("Fetching state from Recce Cloud...")
             metadata = self._get_metadata_from_recce_cloud()
-            if metadata is None:
-                return None, None
-            state_etag = metadata.get("etag")
+            if metadata:
+                state_etag = metadata.get("etag")
+            else:
+                state_etag = None
             if self.state_etag and state_etag == self.state_etag:
                 return self.state, self.state_etag
 
             return self._load_state_from_recce_cloud(), state_etag
 
     def _get_metadata_from_recce_cloud(self) -> Union[dict, None]:
-        recce_cloud = RecceCloud(token=self.cloud_options.get("token"))
-        return recce_cloud.get_artifact_metadata(pr_info=self.pr_info)
+        recce_cloud = RecceCloud(token=self.token)
+        return recce_cloud.get_artifact_metadata(pr_info=self.pr_info) if self.pr_info else None
 
     def _load_state_from_recce_cloud(self) -> Union[RecceState, None]:
         import tempfile
 
         import requests
 
-        recce_cloud = RecceCloud(token=self.cloud_options.get("token"))
-        presigned_url = recce_cloud.get_presigned_url(
-            method=PresignedUrlMethod.DOWNLOAD,
-            pr_id=self.pr_info.id,
-            repository=self.pr_info.repository,
-            artifact_name=RECCE_STATE_COMPRESSED_FILE,
-        )
+        recce_cloud = RecceCloud(token=self.token)
+        password = None
 
-        password = self.cloud_options.get("password")
-        if password is None:
-            raise Exception(RECCE_CLOUD_PASSWORD_MISSING.error_message)
+        if self.catalog == "github":
+            presigned_url = recce_cloud.get_presigned_url_by_github_repo(
+                method=PresignedUrlMethod.DOWNLOAD,
+                pr_id=self.pr_info.id,
+                repository=self.pr_info.repository,
+                artifact_name=RECCE_STATE_COMPRESSED_FILE,
+            )
+
+            password = self.cloud_options.get("password")
+            if password is None:
+                raise RecceException(RECCE_CLOUD_PASSWORD_MISSING.error_message)
+        elif self.catalog == "preview":
+            share_id = self.cloud_options.get("share_id")
+            presigned_url = recce_cloud.get_presigned_url_by_share_id(
+                method=PresignedUrlMethod.DOWNLOAD, share_id=share_id
+            )
 
         with tempfile.NamedTemporaryFile() as tmp:
-            headers = s3_sse_c_headers(password)
+            headers = s3_sse_c_headers(password) if password else None
             response = requests.get(presigned_url, headers=headers)
             if response.status_code == 404:
                 self.error_message = "The state file is not found in Recce Cloud."
                 return None
             elif response.status_code != 200:
                 self.error_message = response.text
-                raise Exception(
+                raise RecceException(
                     f"{response.status_code} Failed to download the state file from Recce Cloud. The password could be wrong."
                 )
             with open(tmp.name, "wb") as f:
                 f.write(response.content)
-            return RecceState.from_file(tmp.name, file_type=SupportedFileTypes.GZIP)
+
+            file_type = SupportedFileTypes.GZIP if self.catalog == "github" else SupportedFileTypes.FILE
+            return RecceState.from_file(tmp.name, file_type=file_type)
 
     def _load_state_from_s3_bucket(self) -> Union[RecceState, None]:
         import tempfile
@@ -408,11 +450,19 @@ class RecceStateLoader:
 
         s3_client = boto3.client("s3")
         s3_bucket_name = self.cloud_options.get("host").replace("s3://", "")
-        s3_bucket_key = f"github/{self.pr_info.repository}/pulls/{self.pr_info.id}/{RECCE_STATE_COMPRESSED_FILE}"
+
+        if self.catalog == "github":
+            s3_bucket_key = (
+                f"{self.catalog}/{self.pr_info.repository}/pulls/{self.pr_info.id}/{RECCE_STATE_COMPRESSED_FILE}"
+            )
+        elif self.catalog == "preview":
+            s3_bucket_key = f"{self.catalog}/{self.share_id}/{RECCE_STATE_FILE}"
+        else:
+            raise RecceException(f"Unsupported catalog type. {self.catalog} is not supported.")
 
         rc, error_message = check_s3_bucket(s3_bucket_name)
         if rc is False:
-            raise Exception(error_message)
+            raise RecceException(error_message)
 
         with tempfile.NamedTemporaryFile() as tmp:
             try:
@@ -427,8 +477,11 @@ class RecceStateLoader:
             return RecceState.from_file(tmp.name, file_type=SupportedFileTypes.GZIP)
 
     def _export_state_to_cloud(self) -> Tuple[Union[str, None], str]:
-        if (self.pr_info is None) or (self.pr_info.id is None) or (self.pr_info.repository is None):
-            raise Exception("Cannot get the pull request information from GitHub.")
+        if self.catalog == "github":
+            if (self.pr_info is None) or (self.pr_info.id is None) or (self.pr_info.repository is None):
+                raise RecceException("Cannot get the pull request information from GitHub.")
+        elif self.catalog == "preview":
+            pass
 
         check_status = CheckDAO().status()
         metadata = {
@@ -443,9 +496,9 @@ class RecceStateLoader:
             logger.info("Store recce state to Recce Cloud")
             message = self._export_state_to_recce_cloud(metadata=metadata)
             metadata = self._get_metadata_from_recce_cloud()
-            if metadata is None:
-                return None
-            state_etag = metadata.get("etag")
+            state_etag = metadata.get("etag") if metadata else None
+            if message:
+                logger.warning(message)
             return message, state_etag
 
     def _export_state_to_recce_cloud(self, metadata: dict = None) -> Union[str, None]:
@@ -453,24 +506,42 @@ class RecceStateLoader:
 
         import requests
 
-        presigned_url = RecceCloud(token=self.cloud_options.get("token")).get_presigned_url(
-            method=PresignedUrlMethod.UPLOAD,
-            repository=self.pr_info.repository,
-            artifact_name=RECCE_STATE_COMPRESSED_FILE,
-            pr_id=self.pr_info.id,
-            metadata=metadata,
-        )
+        if self.catalog == "github":
+            presigned_url = RecceCloud(token=self.token).get_presigned_url_by_github_repo(
+                method=PresignedUrlMethod.UPLOAD,
+                repository=self.pr_info.repository,
+                artifact_name=RECCE_STATE_COMPRESSED_FILE,
+                pr_id=self.pr_info.id,
+                metadata=metadata,
+            )
+        elif self.catalog == "preview":
+            share_id = self.cloud_options.get("share_id")
+            presigned_url = RecceCloud(token=self.token).get_presigned_url_by_share_id(
+                method=PresignedUrlMethod.UPLOAD,
+                share_id=share_id,
+                metadata=metadata,
+            )
         compress_passwd = self.cloud_options.get("password")
-        headers = s3_sse_c_headers(compress_passwd)
+        if compress_passwd:
+            headers = s3_sse_c_headers(compress_passwd)
+        else:
+            headers = {}
+
         if metadata:
             headers["x-amz-tagging"] = urlencode(metadata)
         with tempfile.NamedTemporaryFile() as tmp:
-            self._export_state_to_file(tmp.name, file_type=SupportedFileTypes.GZIP)
-            response = requests.put(presigned_url, data=open(tmp.name, "rb").read(), headers=headers)
-            if response.status_code != 200:
+            if self.catalog == "github":
+                file_type = SupportedFileTypes.GZIP
+            elif self.catalog == "preview":
+                file_type = SupportedFileTypes.FILE
+            self._export_state_to_file(tmp.name, file_type=file_type)
+
+            with open(tmp.name, "rb") as fd:
+                response = requests.put(presigned_url, data=fd.read(), headers=headers)
+            if response.status_code not in [200, 204]:
                 self.error_message = response.text
                 return "Failed to upload the state file to Recce Cloud. Reason: " + response.text
-        return "The state file is uploaded to Recce Cloud."
+        return None
 
     def _export_state_to_s3_bucket(self, metadata: dict = None) -> Union[str, None]:
         import tempfile
@@ -479,11 +550,18 @@ class RecceStateLoader:
 
         s3_client = boto3.client("s3")
         s3_bucket_name = self.cloud_options.get("host").replace("s3://", "")
-        s3_bucket_key = f"github/{self.pr_info.repository}/pulls/{self.pr_info.id}/{RECCE_STATE_COMPRESSED_FILE}"
+        if self.catalog == "github":
+            s3_bucket_key = (
+                f"{self.catalog}/{self.pr_info.repository}/pulls/{self.pr_info.id}/{RECCE_STATE_COMPRESSED_FILE}"
+            )
+        elif self.catalog == "preview":
+            s3_bucket_key = f"{self.catalog}/{self.share_id}/{RECCE_STATE_FILE}"
+        else:
+            raise RecceException(f"Unsupported catalog type. {self.catalog} is not supported.")
 
         rc, error_message = check_s3_bucket(s3_bucket_name)
         if rc is False:
-            raise Exception(error_message)
+            raise RecceException(error_message)
 
         with tempfile.NamedTemporaryFile() as tmp:
             self._export_state_to_file(tmp.name, file_type=SupportedFileTypes.GZIP)
@@ -495,7 +573,7 @@ class RecceStateLoader:
                 # Casting all the values under metadata to string
                 ExtraArgs={"Metadata": {k: str(v) for k, v in metadata.items()}},
             )
-        RecceCloud(token=self.cloud_options.get("token")).update_github_pull_request_check(self.pr_info, metadata)
+        RecceCloud(token=self.token).update_github_pull_request_check(self.pr_info, metadata)
         return f"The state file is uploaded to ' s3://{s3_bucket_name}/{s3_bucket_key}'"
 
     def _get_artifact_metadata_from_s3_bucket(self, artifact_name: str) -> Union[dict, None]:
@@ -510,7 +588,7 @@ class RecceStateLoader:
             return metadata
         except botocore.exceptions.ClientError as e:
             self.error_message = e.response.get("Error", {}).get("Message")
-            raise Exception("Failed to get artifact metadata from Recce Cloud.")
+            raise RecceException("Failed to get artifact metadata from Recce Cloud.")
 
     def _export_state_to_file(
         self, file_path: Optional[str] = None, file_type: SupportedFileTypes = SupportedFileTypes.FILE
@@ -538,15 +616,16 @@ class RecceCloudStateManager:
         self.pr_info = None
         self.error_message = None
         self.hint_message = None
+        self.github_token = self.cloud_options.get("github_token")
 
-        if not self.cloud_options.get("token"):
-            raise Exception(RECCE_CLOUD_TOKEN_MISSING.error_message)
-        self.pr_info = fetch_pr_metadata(cloud=True, github_token=self.cloud_options.get("token"))
+        if not self.github_token:
+            raise RecceException(RECCE_CLOUD_TOKEN_MISSING.error_message)
+        self.pr_info = fetch_pr_metadata(cloud=True, github_token=self.github_token)
         if self.pr_info.id is None:
-            raise Exception("Cannot get the pull request information from GitHub.")
+            raise RecceException("Cannot get the pull request information from GitHub.")
 
     def verify(self) -> bool:
-        if self.cloud_options.get("token") is None:
+        if self.github_token is None:
             self.error_message = RECCE_CLOUD_TOKEN_MISSING.error_message
             self.hint_message = RECCE_CLOUD_TOKEN_MISSING.hint_message
             return False
@@ -561,7 +640,7 @@ class RecceCloudStateManager:
         return self.error_message, self.hint_message
 
     def _check_state_in_recce_cloud(self) -> bool:
-        return RecceCloud(token=self.cloud_options.get("token")).check_artifacts_exists(self.pr_info)
+        return RecceCloud(token=self.github_token).check_artifacts_exists(self.pr_info)
 
     def _check_state_in_s3_bucket(self) -> bool:
         import boto3
@@ -588,7 +667,7 @@ class RecceCloudStateManager:
 
         import requests
 
-        presigned_url = RecceCloud(token=self.cloud_options.get("token")).get_presigned_url(
+        presigned_url = RecceCloud(token=self.github_token).get_presigned_url_by_github_repo(
             method=PresignedUrlMethod.UPLOAD,
             repository=self.pr_info.repository,
             artifact_name=RECCE_STATE_COMPRESSED_FILE,
@@ -616,7 +695,7 @@ class RecceCloudStateManager:
 
         rc, error_message = check_s3_bucket(s3_bucket_name)
         if rc is False:
-            raise Exception(error_message)
+            raise RecceException(error_message)
 
         with tempfile.NamedTemporaryFile() as tmp:
             state.to_file(tmp.name, file_type=SupportedFileTypes.GZIP)
@@ -628,12 +707,12 @@ class RecceCloudStateManager:
                 # Casting all the values under metadata to string
                 ExtraArgs={"Metadata": {k: str(v) for k, v in metadata.items()}},
             )
-        RecceCloud(token=self.cloud_options.get("token")).update_github_pull_request_check(self.pr_info, metadata)
+        RecceCloud(token=self.github_token).update_github_pull_request_check(self.pr_info, metadata)
         return f"The state file is uploaded to ' s3://{s3_bucket_name}/{s3_bucket_key}'"
 
     def upload_state_to_cloud(self, state: RecceState) -> Union[str, None]:
         if (self.pr_info is None) or (self.pr_info.id is None) or (self.pr_info.repository is None):
-            raise Exception("Cannot get the pull request information from GitHub.")
+            raise RecceException("Cannot get the pull request information from GitHub.")
 
         checks = state.checks
 
@@ -658,7 +737,7 @@ class RecceCloudStateManager:
 
         rc, error_message = check_s3_bucket(s3_bucket_name)
         if rc is False:
-            raise Exception(error_message)
+            raise RecceException(error_message)
 
         response = s3_client.get_object(Bucket=s3_bucket_name, Key=s3_bucket_key)
         byte_stream = io.BytesIO(response["Body"].read())
@@ -676,7 +755,7 @@ class RecceCloudStateManager:
 
         import requests
 
-        presigned_url = RecceCloud(token=self.cloud_options.get("token")).get_presigned_url(
+        presigned_url = RecceCloud(token=self.github_token).get_presigned_url_by_github_repo(
             method=PresignedUrlMethod.DOWNLOAD,
             repository=self.pr_info.repository,
             artifact_name=RECCE_STATE_COMPRESSED_FILE,
@@ -685,13 +764,13 @@ class RecceCloudStateManager:
 
         password = self.cloud_options.get("password")
         if password is None:
-            raise Exception(RECCE_CLOUD_PASSWORD_MISSING.error_message)
+            raise RecceException(RECCE_CLOUD_PASSWORD_MISSING.error_message)
 
         headers = s3_sse_c_headers(password)
         response = requests.get(presigned_url, headers=headers)
 
         if response.status_code != 200:
-            raise Exception(
+            raise RecceException(
                 f"{response.status_code} Failed to download the state file from Recce Cloud. The password could be wrong."
             )
 
@@ -707,7 +786,7 @@ class RecceCloudStateManager:
 
     def download_state_from_cloud(self, filepath: str) -> Union[str, None]:
         if (self.pr_info is None) or (self.pr_info.id is None) or (self.pr_info.repository is None):
-            raise Exception("Cannot get the pull request information from GitHub.")
+            raise RecceException("Cannot get the pull request information from GitHub.")
 
         if self.cloud_options.get("host", "").startswith("s3://"):
             logger.debug("Download state file from AWS S3 bucket...")
@@ -738,12 +817,12 @@ class RecceCloudStateManager:
         delete_response = s3_client.delete_objects(Bucket=s3_bucket_name, Delete={"Objects": delete_objects})
         if "Deleted" not in delete_response:
             return False, "Failed to delete the state file from the S3 bucket."
-        RecceCloud(token=self.cloud_options.get("token")).update_github_pull_request_check(self.pr_info)
+        RecceCloud(token=self.github_token).update_github_pull_request_check(self.pr_info)
         return True, None
 
     def _purge_state_from_recce_cloud(self) -> (bool, str):
         try:
-            RecceCloud(token=self.cloud_options.get("token")).purge_artifacts(self.pr_info)
+            RecceCloud(token=self.github_token).purge_artifacts(self.pr_info)
         except RecceCloudException as e:
             return False, e.reason
         return True, None

recce/util/api_token.py

@@ -17,7 +17,9 @@ def show_invalid_api_token_message():
     Show the message when the API token is invalid.
     """
     console.print("[[red]Error[/red]] Invalid Recce Cloud API token.")
-    console.print(f"Please check your API token from {RECCE_CLOUD_BASE_URL}/settings#tokens")
+    console.print("Please associate with your Recce Cloud account by the following command 'recce connect-to-cloud'.")
+    console.print(
+        "For more information, please visit: https://docs.reccehq.com/recce-cloud/share-recce-session-securely/#configure-recce-cloud-association-manually")
 
 
 def prepare_api_token(

recce/util/recce_cloud.py

@@ -66,7 +66,7 @@ class RecceCloud:
             pass
         return False
 
-    def get_presigned_url(
+    def get_presigned_url_by_github_repo(
         self,
         method: PresignedUrlMethod,
         repository: str,
@@ -78,7 +78,16 @@ class RecceCloud:
         response = self._fetch_presigned_url(method, repository, artifact_name, metadata, pr_id, branch)
         return response.get("presigned_url")
 
-    def get_download_presigned_url_with_tags(
+    def get_presigned_url_by_share_id(
+        self,
+        method: PresignedUrlMethod,
+        share_id: str,
+        metadata: dict = None,
+    ) -> str:
+        response = self._fetch_presigned_url_by_share_id(method, share_id, metadata=metadata)
+        return response.get("presigned_url")
+
+    def get_download_presigned_url_by_github_repo_with_tags(
         self, repository: str, artifact_name: str, branch: str = None
     ) -> (str, dict):
         response = self._fetch_presigned_url(PresignedUrlMethod.DOWNLOAD, repository, artifact_name, branch=branch)
@@ -110,6 +119,33 @@ class RecceCloud:
             )
         return response.json()
 
+    def _fetch_presigned_url_by_share_id(
+        self,
+        method: PresignedUrlMethod,
+        share_id: str,
+        metadata: dict = None,
+    ):
+        api_url = f"{self.base_url}/shares/{share_id}/presigned/{method}"
+        data = None
+        # Only provide metadata for upload requests
+        if method == PresignedUrlMethod.UPLOAD:
+            # Covert metadata values to strings to ensure JSON serializability
+            data = {"metadata": {key: str(value) for key, value in metadata.items()}} if metadata else None
+        response = self._request(
+            "POST",
+            api_url,
+            json=data,
+        )
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to {method} artifact {preposition} Recce Cloud.".format(
+                    method=method, preposition="from" if method == PresignedUrlMethod.DOWNLOAD else "to"
+                ),
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        return response.json()
+
     def get_artifact_metadata(self, pr_info: PullRequestInfo) -> dict:
         api_url = f"{self.base_url}/{pr_info.repository}/pulls/{pr_info.id}/metadata"
         response = self._request("GET", api_url)

{recce_nightly-1.11.0.20250708.dist-info → recce_nightly-1.12.0.20250709.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: recce-nightly
-Version: 1.11.0.20250708
+Version: 1.12.0.20250709
 Summary: Environment diff tool for dbt
 Home-page: https://github.com/InfuseAI/recce
 Author: InfuseAI Dev Team