recce-nightly 0.62.0.20250417__py3-none-any.whl → 1.30.0.20251221__py3-none-any.whl

recce/event/collector.py

@@ -4,20 +4,19 @@ import platform
 import sys
 import time
 from contextlib import contextmanager
-from datetime import datetime
+from datetime import datetime, timezone
 from json import JSONDecodeError
-from datetime import timezone
 
 import portalocker
 import requests
 
-from recce import __version__, is_ci_env
+from recce import __version__, is_ci_env, is_recce_cloud_instance
 from recce.github import is_github_codespace
 
 
 class Collector:
     def __init__(self):
-        self._api_endpoint = 'https://api.amplitude.com/2/httpapi'
+        self._api_endpoint = "https://api.amplitude.com/2/httpapi"
         self._api_key = None
         self._user_id = None
 
@@ -26,6 +25,7 @@ class Collector:
         self._upload_threshold = 10
         self._is_ci: bool = is_ci_env()
         self._is_github_codespace: bool = is_github_codespace()
+        self._is_recce_cloud_instance: bool = is_recce_cloud_instance()
         self._flush_timer = None
 
     def schedule_flush(self):
@@ -35,6 +35,7 @@ class Collector:
 
         # send async thread
         import threading
+
         if self._flush_timer:
             try:
                 self._flush_timer.cancel()
@@ -59,11 +60,18 @@ class Collector:
         self._unsend_events_file = unsend_events_file
         self._check_required_files()
 
-    def _log_event(self, user_id, event_type, created_at, user_properties, event_properties, ):
+    def _log_event(
+        self,
+        user_id,
+        event_type,
+        created_at,
+        user_properties,
+        event_properties,
+    ):
         event = dict(
             user_id=user_id,
             event_type=event_type,
-            ip='$remote',
+            ip="$remote",
             time=int(time.mktime(created_at.timetuple())),
             user_properties=user_properties,
             event_properties=event_properties,
@@ -91,7 +99,7 @@ class Collector:
         else:
             # Convert to UTC timezone
             created_at = event_triggered_at.astimezone(timezone.utc)
-        python_version = f'{sys.version_info.major}.{sys.version_info.minor}'
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
 
         # when the recce is running in automation use cases
         # replace the user id with project_id to avoid so many unique user id
@@ -102,6 +110,7 @@ class Collector:
             python_version=python_version,
             is_ci=self._is_ci,
             is_github_codespace=self._is_github_codespace,
+            is_recce_cloud_instance=self._is_recce_cloud_instance,
         )
 
         if user_properties is not None:
@@ -120,17 +129,18 @@ class Collector:
         if not os.path.exists(user_home):
             os.makedirs(user_home, exist_ok=True)
         if not os.path.exists(self._unsend_events_file):
-            with portalocker.Lock(self._unsend_events_file, 'w+', timeout=5) as f:
-                f.write(json.dumps({'unsend_events': []}))
+            with portalocker.Lock(self._unsend_events_file, "w+", timeout=5) as f:
+                f.write(json.dumps({"unsend_events": []}))
 
     def _is_full(self):
-        with portalocker.Lock(self._unsend_events_file, 'r+', timeout=5) as f:
+        with portalocker.Lock(self._unsend_events_file, "r+", timeout=5) as f:
             o = json.loads(f.read())
-            return len(o.get('unsend_events', [])) >= self._upload_threshold
+            return len(o.get("unsend_events", [])) >= self._upload_threshold
 
     @contextmanager
     def load_json(self):
-        with portalocker.Lock(self._unsend_events_file, 'r+', timeout=5) as f:
+        with portalocker.Lock(self._unsend_events_file, "r+", timeout=5) as f:
+            o = None
             try:
                 o = json.loads(f.read())
                 yield o
@@ -140,15 +150,16 @@ class Collector:
             finally:
                 f.seek(0)
                 f.truncate()
-                f.write(json.dumps(o))
+                if o is not None:
+                    f.write(json.dumps(o))
 
     def send_events(self):
         with self.load_json() as o:
             payload = dict(
                 api_key=self._api_key,
-                events=o['unsend_events'],
+                events=o["unsend_events"],
             )
-            o['unsend_events'] = []
+            o["unsend_events"] = []
         try:
             requests.post(self._api_endpoint, json=payload)
         except Exception:
@@ -157,17 +168,17 @@ class Collector:
 
     def _store_to_file(self, event):
         with self.load_json() as o:
-            events = o.get('unsend_events', None)
+            events = o.get("unsend_events", None)
             if events is None:
-                o['unsend_events'] = []
+                o["unsend_events"] = []
 
-            o['unsend_events'].append(event)
+            o["unsend_events"].append(event)
 
     def _cleanup_unsend_events(self):
         with self.load_json() as o:
-            events = o.get('unsend_events', None)
+            events = o.get("unsend_events", None)
             if events is None:
-                o['unsend_events'] = []
+                o["unsend_events"] = []
 
-            while len(o['unsend_events']) > self._delete_threshold:
-                o['unsend_events'].pop(0)
+            while len(o["unsend_events"]) > self._delete_threshold:
+                o["unsend_events"].pop(0)

recce/event/track.py

@@ -18,8 +18,8 @@ from recce.git import current_branch, hosting_repo
 
 console = Console()
 
-_enable_traceback: bool = os.environ.get('RECCE_PRINT_TRACEBACK') == '1'
-logger = logging.getLogger('uvicorn')
+_enable_traceback: bool = os.environ.get("RECCE_PRINT_TRACEBACK") == "1"
+logger = logging.getLogger("uvicorn")
 
 
 class TrackCommand(Command):
@@ -39,11 +39,23 @@ class TrackCommand(Command):
         deprecated: bool = False,
         beta: bool = False,
     ) -> None:
-        super(TrackCommand, self).__init__(name, context_settings, callback, params, help, epilog, short_help,
-                                           options_metavar, add_help_option, no_args_is_help, hidden, deprecated)
+        super(TrackCommand, self).__init__(
+            name,
+            context_settings,
+            callback,
+            params,
+            help,
+            epilog,
+            short_help,
+            options_metavar,
+            add_help_option,
+            no_args_is_help,
+            hidden,
+            deprecated,
+        )
 
     def _show_error_message(self, msg, params):
-        if params.get('debug'):
+        if params.get("debug"):
             console.print_exception(show_locals=True)
         else:
             print(traceback.format_exc())
@@ -51,39 +63,39 @@ class TrackCommand(Command):
             # console.out(msg, highlight=False)
 
     def _show_hint_message(self, hint):
-        console.print(f'[bold yellow]Hint[/bold yellow]:\n  {escape(hint)}')
+        console.print(f"[bold yellow]Hint[/bold yellow]:\n  {escape(hint)}")
 
     def invoke(self, ctx: Context) -> t.Any:
         status = False
         start_time = time.time()
-        reason = 'error'
-        event.set_exception_tag('command', ctx.command.name)
+        reason = "error"
+        event.set_exception_tag("command", ctx.command.name)
         event.log_codespaces_events(ctx.command.name)
 
         try:
             ret = super(TrackCommand, self).invoke(ctx)
             if ret is None or ret == 0:
                 status = True
-                reason = 'ok'
+                reason = "ok"
             else:
-                reason = 'error'
+                reason = "error"
                 sys.exit(ret)
             return ret
         except RecceException as e:
             logger.debug(traceback.format_exc())
             console.log("[Error] " + str(e))
-            reason = 'error'
+            reason = "error"
             sys.exit(1)
         except SystemExit as e:
-            reason = 'error'
+            reason = "error"
             raise e
         except KeyboardInterrupt as e:
-            reason = 'aborted'
+            reason = "aborted"
             raise e
         except Exception as e:
             self._show_error_message(str(e), ctx.params)
             event.capture_exception(e)
-            reason = 'fatal'
+            reason = "fatal"
             event.flush_exceptions()
             sys.exit(1)
         finally:
@@ -93,32 +105,32 @@ class TrackCommand(Command):
             branch = current_branch()
             command = ctx.command.name
             duration = end_time - start_time
-            target_path = ctx.params.get('target_path', None)
-            target_base_path = ctx.params.get('target_base_path', None)
+            target_path = ctx.params.get("target_path", None)
+            target_base_path = ctx.params.get("target_base_path", None)
             props = dict(
                 command=command,
                 status=status,
                 reason=reason,
                 duration=duration,
-                cloud=ctx.params.get('cloud', False),
-                review=ctx.params.get('review', False),
-                debug=ctx.params.get('debug', False),
+                cloud=ctx.params.get("cloud", False),
+                review=ctx.params.get("review", False),
+                debug=ctx.params.get("debug", False),
             )
 
             if runner is not None:
-                props['runner_type'] = runner
+                props["runner_type"] = runner
 
             if repo is not None:
-                props['repository'] = sha256(repo.encode()).hexdigest()
+                props["repository"] = sha256(repo.encode()).hexdigest()
 
             if branch is not None:
-                props['branch'] = sha256(branch.encode()).hexdigest()
+                props["branch"] = sha256(branch.encode()).hexdigest()
 
             if target_path is not None:
-                props['target_path'] = sha256(target_path.encode()).hexdigest()
+                props["target_path"] = sha256(target_path.encode()).hexdigest()
 
             if target_base_path is not None:
-                props['target_base_path'] = sha256(target_base_path.encode()).hexdigest()
+                props["target_base_path"] = sha256(target_base_path.encode()).hexdigest()
 
             try:
                 recce_context = load_context()
@@ -128,9 +140,19 @@ class TrackCommand(Command):
 
             if recce_context is not None:
                 if recce_context.adapter_type == "dbt":
-                    props['adapter_type'] = 'DBT'
+                    props["adapter_type"] = "DBT"
+                    # Add dbt warehouse type only for dbt adapter
+                    try:
+                        from recce.adapter.dbt_adapter import DbtAdapter
+
+                        dbt_adapter: DbtAdapter = recce_context.adapter
+                        warehouse_type = dbt_adapter.adapter.type()
+                        props["warehouse_type"] = warehouse_type
+                    except Exception:
+                        # If we can't get the warehouse type, skip it
+                        pass
                 elif recce_context.adapter_type == "sqlmesh":
-                    props['adapter_type'] = 'SQLMesh'
+                    props["adapter_type"] = "SQLMesh"
 
-            event.log_event(props, 'command', params=ctx.params)
+            event.log_event(props, "command", params=ctx.params)
             event.flush_events()

recce/exceptions.py

@@ -7,7 +7,7 @@ class RecceException(Exception):
 
 class RecceCancelException(RecceException):
     def __init__(self):
-        super().__init__('Cancelled', False)
+        super().__init__("Cancelled", False)
 
 
 class RecceConfigException(RecceException):

recce/git.py

@@ -1,12 +1,12 @@
 import os
 
-from git import Repo, InvalidGitRepositoryError
+from git import InvalidGitRepositoryError, Repo
 
 
 def current_default_branch():
     try:
         repo = Repo(search_parent_directories=True)
-        return repo.remotes.origin.refs['HEAD'].reference.remote_head
+        return repo.remotes.origin.refs["HEAD"].reference.remote_head
     except Exception:
         return None
 
@@ -53,19 +53,19 @@ def commit_hash_from_branch(branch: str, short_length: int = 7, short: bool = Fa
         return None
 
 
-def hosting_repo(remote: str = 'origin'):
+def hosting_repo(remote: str = "origin"):
     try:
         repo = Repo(search_parent_directories=True)
         origin_url = repo.remote(name=remote).url
         remote_repo = None
 
-        if origin_url.startswith('git@'):
+        if origin_url.startswith("git@"):
             # Handle git@github.com:user/repo.git
-            remote_repo = origin_url.split(':')[1].replace('.git', '')
+            remote_repo = origin_url.split(":")[1].replace(".git", "")
 
-        elif origin_url.startswith('https://') or origin_url.startswith('http://'):
+        elif origin_url.startswith("https://") or origin_url.startswith("http://"):
             # Handle https://github.com/user/repo.git or http://github.com/user/repo.git
-            remote_repo = '/'.join(origin_url.split('/')[-2:]).replace('.git', '')
+            remote_repo = "/".join(origin_url.split("/")[-2:]).replace(".git", "")
 
         return remote_repo
     except ValueError:

recce/github.py

@@ -3,10 +3,10 @@ import os
 import re
 import zipfile
 from datetime import datetime
-from typing import List, Tuple, Optional
+from typing import List, Optional, Tuple
 
 import requests
-from github import Artifact, Github, Auth, UnknownObjectException, PullRequest
+from github import Artifact, Auth, Github, PullRequest, UnknownObjectException
 
 from recce.git import current_branch, hosting_repo
 
@@ -16,7 +16,7 @@ def download_artifact(github_token: str, artifact: Artifact) -> List[str]:
     Download the artifact from the Github.
     """
     headers = {
-        'Authorization': f'Bearer {github_token}',
+        "Authorization": f"Bearer {github_token}",
     }
     r = requests.get(artifact.archive_download_url, headers=headers)
     r.raise_for_status()
@@ -27,17 +27,17 @@ def download_artifact(github_token: str, artifact: Artifact) -> List[str]:
 
 def recce_ci_artifact(**kwargs):
     """
-        Download the artifact from the GitHub CI.
+    Download the artifact from the GitHub CI.
     """
-    from rich.console import Console
-
     import git
+
     # Authentication is defined via github.Auth
     from github import Auth, Github
+    from rich.console import Console
 
     console = Console()
-    github_token = kwargs.get('github_token')
-    github_repository = kwargs.get('github_repository')
+    github_token = kwargs.get("github_token")
+    github_repository = kwargs.get("github_repository")
 
     if github_token is None:
         console.print("[[red]Error[/red]] Missing GitHub token. Please provide a GitHub token.")
@@ -70,11 +70,11 @@ def recce_ci_artifact(**kwargs):
 
     head_branch = github_repo.get_branch(current_branch)
 
-    console.rule('GitHub Repository Information')
-    console.print(f'Repository:     {github_repository}')
-    console.print(f'Current Branch: {current_branch}')
+    console.rule("GitHub Repository Information")
+    console.print(f"Repository:     {github_repository}")
+    console.print(f"Current Branch: {current_branch}")
 
-    pull_requests = github_repo.get_pulls(head=f'{github_owner}:{current_branch}')
+    pull_requests = github_repo.get_pulls(head=f"{github_owner}:{current_branch}")
     if pull_requests.totalCount == 0:
         # No pull request found for the current branch
         console.print("[[red]Error[/red]] No pull request found for the current branch.")
@@ -82,32 +82,32 @@ def recce_ci_artifact(**kwargs):
 
     pr = pull_requests[0]
 
-    console.rule('GitHub Pull Request Information')
-    console.print(f'{pr.title} - {pr.html_url}')
-    console.print(f'State: {pr.state.title()}')
-    console.print(f'Author: {pr.user.name}')
-    console.print(f'Created At: {pr.created_at}')
+    console.rule("GitHub Pull Request Information")
+    console.print(f"{pr.title} - {pr.html_url}")
+    console.print(f"State: {pr.state.title()}")
+    console.print(f"Author: {pr.user.name}")
+    console.print(f"Created At: {pr.created_at}")
 
     workflow_runs = github_repo.get_workflow_runs(
-        event='pull_request',
-        status='success',
+        event="pull_request",
+        status="success",
         branch=head_branch,
     )
     if workflow_runs.totalCount == 0:
         console.print("[[yellow]Skip[/yellow]] No successful workflow runs found.")
         return 0
     last_workflow_run = workflow_runs[0]
-    console.rule('GitHub Workflow Run Information')
-    console.print(f'Last Workflow Run: {last_workflow_run.name} {last_workflow_run.html_url}')
+    console.rule("GitHub Workflow Run Information")
+    console.print(f"Last Workflow Run: {last_workflow_run.name} {last_workflow_run.html_url}")
     artifacts = last_workflow_run.get_artifacts()
     if artifacts.totalCount == 0:
         console.print("[[yellow]Skip[/yellow]] No artifacts found.")
         return 0
     for artifact in artifacts:
-        console.print(f'Artifact: {artifact.name} {artifact.archive_download_url}')
+        console.print(f"Artifact: {artifact.name} {artifact.archive_download_url}")
         artifact_files = download_artifact(github_token, artifact)
         console.print(f'Extracted Files: {", ".join(artifact_files)}')
-    console.rule('Complete')
+    console.rule("Complete")
     return 0
 
 
@@ -121,7 +121,7 @@ def get_pull_request(branch, owner, repo_name, github_token=None) -> Tuple[Optio
 
     try:
         repo = g.get_repo(f"{owner}/{repo_name}")
-        pulls = repo.get_pulls(state='open')
+        pulls = repo.get_pulls(state="open")
 
         for pr in pulls:
             if pr.head.ref == branch:
@@ -129,7 +129,10 @@ def get_pull_request(branch, owner, repo_name, github_token=None) -> Tuple[Optio
 
     except UnknownObjectException:
         if github_token is not None:
-            return None, f"Repository {owner}/{repo_name} not found. If it is private repo, please add the 'repo' scope to the token."
+            return (
+                None,
+                f"Repository {owner}/{repo_name} not found. If it is private repo, please add the 'repo' scope to the token.",
+            )
 
     return None, None
 
@@ -139,53 +142,54 @@ def recce_pr_information(github_token=None) -> Tuple[Optional[type(PullRequest)]
     repo = hosting_repo()
 
     if not repo:
-        return None, 'This is not a git repository.'
-    if '/' not in repo:
-        return None, 'This is not a GitHub repository.'
+        return None, "This is not a git repository."
+    if "/" not in repo:
+        return None, "This is not a GitHub repository."
 
-    owner, repo_name = repo.split('/')
+    owner, repo_name = repo.split("/")
 
     github_token = github_token if github_token else os.getenv("GITHUB_TOKEN")
     return get_pull_request(branch, owner, repo_name, github_token)
 
 
 def is_github_codespace():
-    return os.getenv('CODESPACES') == 'true'
+    return os.getenv("CODESPACES") == "true"
 
 
 def get_github_codespace_name():
-    return os.getenv('CODESPACE_NAME')
+    return os.getenv("CODESPACE_NAME")
 
 
 def get_github_codespace_info():
     if is_github_codespace() is False:
         return None
 
-    codespace_name = os.environ.get('CODESPACE_NAME')
-    github_token = os.environ.get('GITHUB_TOKEN')
+    codespace_name = os.environ.get("CODESPACE_NAME")
+    github_token = os.environ.get("GITHUB_TOKEN")
 
     response = requests.get(
-        f'https://api.github.com/user/codespaces/{codespace_name}',
+        f"https://api.github.com/user/codespaces/{codespace_name}",
         headers={
-            'Accept': 'application/vnd.github+json',
-            'Authorization': f'token {github_token}',
-            'X-GitHub-Api-Version': '2022-11-28',
-        })
+            "Accept": "application/vnd.github+json",
+            "Authorization": f"token {github_token}",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    )
 
     if response.status_code != 200:
         return None
     codespace_info = response.json()
 
     return dict(
-        name=codespace_info.get('name'),
-        machine=codespace_info.get('machine'),
-        prebuild=codespace_info.get('prebuild'),
-        created_at=codespace_info.get('created_at'),
-        updated_at=codespace_info.get('updated_at'),
-        last_used_at=codespace_info.get('last_used_at'),
-        state=codespace_info.get('state'),
-        location=codespace_info.get('location'),
-        idle_timeout_minutes=codespace_info.get('idle_timeout_minutes'),
+        name=codespace_info.get("name"),
+        machine=codespace_info.get("machine"),
+        prebuild=codespace_info.get("prebuild"),
+        created_at=codespace_info.get("created_at"),
+        updated_at=codespace_info.get("updated_at"),
+        last_used_at=codespace_info.get("last_used_at"),
+        state=codespace_info.get("state"),
+        location=codespace_info.get("location"),
+        idle_timeout_minutes=codespace_info.get("idle_timeout_minutes"),
     )
 
 
@@ -194,25 +198,25 @@ def get_github_codespace_available_at(codespace):
         return None
 
     def search_in_file(file_path, search_string):
-        with open(file_path, 'r') as f:
+        with open(file_path, "r", encoding="utf-8") as f:
             for _, line in enumerate(f, 1):
                 if search_string in line:
                     return line
         return None
 
     def extract_datatime(log_line):
-        pattern = r'\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}).*\]'
+        pattern = r"\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}).*\]"
         match = re.search(pattern, log_line)
         if match:
             datetime_str = match.group(1)
-            return datetime.strptime(datetime_str, '%Y-%m-%d %H:%M:%S.%f')
+            return datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S.%f")
         return None
 
-    github_codepsce_log_dir = '/tmp/codespaces_logs'
+    github_codepsce_log_dir = "/tmp/codespaces_logs"
     try:
         log_file = os.listdir(github_codepsce_log_dir)[-1]  # Get the latest log file
-        start_monitor_line = search_in_file(f'{github_codepsce_log_dir}/{log_file}', 'Starting monitor')
+        start_monitor_line = search_in_file(f"{github_codepsce_log_dir}/{log_file}", "Starting monitor")
         return extract_datatime(start_monitor_line)
     except Exception:
         # If there is any error, use the updated_at time from the codespace info
-        return datetime.fromisoformat(codespace.get('updated_at'))
+        return datetime.fromisoformat(codespace.get("updated_at"))