recce-nightly 1.2.0.20250506__py3-none-any.whl → 1.4.0.20250514__py3-none-any.whl

recce/data/index.txt

@@ -1,7 +1,7 @@
 2:I[86822,[],"ClientPageRoot"]
-3:I[17024,["266","static/chunks/e24bf851-0f8cbc99656833e7.js","517","static/chunks/c1ceaa8b-a1e442154d23515e.js","376","static/chunks/3a92ee20-3b5d922d4157af5e.js","455","static/chunks/6ef81909-694dc38134099299.js","881","static/chunks/8d700b6a-f0b1f6b9e0d97ce2.js","678","static/chunks/3998a672-eaad84bdd88cc73e.js","509","static/chunks/9746af58-d74bef4d03eea6ab.js","648","static/chunks/ce84277d-f42c2c58049cea2d.js","989","static/chunks/47d8844f-79a1b53c66a7d7ec.js","147","static/chunks/a30376cd-7d806e1602f2dc3a.js","995","static/chunks/fee69bc6-f17d36c080742e74.js","739","static/chunks/7a8a3e83-d7fa409d97b38b2b.js","283","static/chunks/450c323b-1bb5db526e54435a.js","303","static/chunks/36e1c10d-bb0210cbd6573a8d.js","22","static/chunks/29e3cc0d-8c150e37dff9631b.js","25","static/chunks/b63b1b3f-7395c74e11a14e95.js","355","static/chunks/7f27ae6c-413f6b869a04183a.js","495","static/chunks/6dc81886-c94b9b91bc2c3caf.js","599","static/chunks/c132bf7d-8102037f9ccf372a.js","971","static/chunks/cd9f8d63-cf0d5a7b0f7a92e8.js","368","static/chunks/368-7587b306577df275.js","931","static/chunks/app/page-cee661090afbd6aa.js"],"default",1]
+3:I[1996,["266","static/chunks/e24bf851-0f8cbc99656833e7.js","517","static/chunks/c1ceaa8b-a1e442154d23515e.js","376","static/chunks/3a92ee20-3b5d922d4157af5e.js","455","static/chunks/6ef81909-694dc38134099299.js","678","static/chunks/3998a672-eaad84bdd88cc73e.js","509","static/chunks/9746af58-d74bef4d03eea6ab.js","648","static/chunks/ce84277d-f42c2c58049cea2d.js","989","static/chunks/47d8844f-79a1b53c66a7d7ec.js","147","static/chunks/a30376cd-7d806e1602f2dc3a.js","995","static/chunks/fee69bc6-f17d36c080742e74.js","739","static/chunks/7a8a3e83-d7fa409d97b38b2b.js","283","static/chunks/450c323b-1bb5db526e54435a.js","303","static/chunks/36e1c10d-bb0210cbd6573a8d.js","22","static/chunks/29e3cc0d-8c150e37dff9631b.js","25","static/chunks/b63b1b3f-7395c74e11a14e95.js","355","static/chunks/7f27ae6c-413f6b869a04183a.js","495","static/chunks/6dc81886-c94b9b91bc2c3caf.js","599","static/chunks/c132bf7d-8102037f9ccf372a.js","971","static/chunks/cd9f8d63-e020f408095ed77c.js","778","static/chunks/778-aef312bffb4c0312.js","931","static/chunks/app/page-7086764277331fcb.js"],"default",1]
 4:I[79137,[],""]
 5:I[63846,[],""]
-0:["Kcbs3GEIyH2LxgLYat0es",[[["",{"children":["__PAGE__",{}]},"$undefined","$undefined",true],["",{"children":["__PAGE__",{},[["$L1",["$","$L2",null,{"props":{"params":{},"searchParams":{}},"Component":"$3"}],[["$","link","0",{"rel":"stylesheet","href":"/_next/static/css/c9ecb46a4b21c126.css","precedence":"next","crossOrigin":"$undefined"}]]],null],null]},[[null,["$","html",null,{"lang":"en","children":["$","body",null,{"suppressHydrationWarning":true,"children":["$","$L4",null,{"parallelRouterKey":"children","segmentPath":["children"],"error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":"404"}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],"notFoundStyles":[]}]}]}]],null],null],["$L6",null]]]]
+0:["E_HPXsXdrqHg2YEHmU3mK",[[["",{"children":["__PAGE__",{}]},"$undefined","$undefined",true],["",{"children":["__PAGE__",{},[["$L1",["$","$L2",null,{"props":{"params":{},"searchParams":{}},"Component":"$3"}],[["$","link","0",{"rel":"stylesheet","href":"/_next/static/css/c9ecb46a4b21c126.css","precedence":"next","crossOrigin":"$undefined"}]]],null],null]},[[[["$","link","0",{"rel":"stylesheet","href":"/_next/static/css/88b8abc134cfd59a.css","precedence":"next","crossOrigin":"$undefined"}]],["$","html",null,{"lang":"en","children":["$","body",null,{"suppressHydrationWarning":true,"children":["$","$L4",null,{"parallelRouterKey":"children","segmentPath":["children"],"error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":"404"}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],"notFoundStyles":[]}]}]}]],null],null],["$L6",null]]]]
 6:[["$","meta","0",{"name":"viewport","content":"width=device-width, initial-scale=1"}],["$","meta","1",{"charSet":"utf-8"}],["$","title","2",{"children":"recce"}],["$","meta","3",{"name":"description","content":"Recce: Data validation toolkit for comprehensive PR review"}],["$","link","4",{"rel":"icon","href":"/favicon.ico","type":"image/x-icon","sizes":"32x32"}]]
 1:null

recce/diff.py

@@ -5,28 +5,22 @@ import pandas as pd
 
 def diff_text(before: str, after: str):
     if before is None and after is None:
-        print('not found in both states')
+        print("not found in both states")
         return
     elif before == after:
-        print('no changes')
+        print("no changes")
         return
 
-    diff_output = difflib.unified_diff(
-        before.splitlines(),
-        after.splitlines(),
-        "base",
-        "current",
-        lineterm=""
-    )
+    diff_output = difflib.unified_diff(before.splitlines(), after.splitlines(), "base", "current", lineterm="")
     for line in diff_output:
         print(line)
 
 
 def diff_dataframe(before: pd.DataFrame, after: pd.DataFrame):
     if before is None and after is None:
-        print('not found in both states')
+        print("not found in both states")
         return
 
     before_aligned, after_aligned = before.align(after)
-    diff = before_aligned.compare(after_aligned, result_names=('base', 'current'))
-    print(diff.to_string(na_rep='-'))
+    diff = before_aligned.compare(after_aligned, result_names=("base", "current"))
+    print(diff.to_string(na_rep="-"))

recce/event/__init__.py

@@ -10,17 +10,21 @@ from typing import Dict
 
 import sentry_sdk
 
-from recce import is_ci_env, get_version, get_runner
+from recce import get_runner, get_version, is_ci_env
 from recce import yaml as pyml
 from recce.event.collector import Collector
 from recce.git import current_branch, hosting_repo
-from recce.github import is_github_codespace, get_github_codespace_info, get_github_codespace_name, \
-    get_github_codespace_available_at
-
-USER_HOME = os.path.expanduser('~')
-RECCE_USER_HOME = os.path.join(USER_HOME, '.recce')
-RECCE_USER_PROFILE = os.path.join(RECCE_USER_HOME, 'profile.yml')
-RECCE_USER_EVENT_PATH = os.path.join(RECCE_USER_HOME, '.unsend_events.json')
+from recce.github import (
+    get_github_codespace_available_at,
+    get_github_codespace_info,
+    get_github_codespace_name,
+    is_github_codespace,
+)
+
+USER_HOME = os.path.expanduser("~")
+RECCE_USER_HOME = os.path.join(USER_HOME, ".recce")
+RECCE_USER_PROFILE = os.path.join(RECCE_USER_HOME, "profile.yml")
+RECCE_USER_EVENT_PATH = os.path.join(RECCE_USER_HOME, ".unsend_events.json")
 
 __version__ = get_version()
 _collector = Collector()
@@ -33,13 +37,13 @@ def init():
 
     # Amplitude init
     _collector.set_api_key(api_key)
-    _collector.set_user_id(user_profile.get('user_id'))
+    _collector.set_user_id(user_profile.get("user_id"))
     _collector.set_unsend_events_file(RECCE_USER_EVENT_PATH)
 
     # Sentry init
     sentry_env = _get_sentry_env()
     sentry_dns = _get_sentry_dns()
-    release_version = __version__ if sentry_env != 'development' else None
+    release_version = __version__ if sentry_env != "development" else None
     sentry_sdk.init(
         dsn=sentry_dns,
         environment=sentry_env,
@@ -47,58 +51,58 @@ def init():
         # Set traces_sample_rate to 1.0 to capture 100%
         # of transactions for performance monitoring.
         # We recommend adjusting this value in production.
-        traces_sample_rate=1.0
+        traces_sample_rate=1.0,
     )
-    sentry_sdk.set_tag('recce.version', __version__)
-    sentry_sdk.set_tag('platform', sys.platform)
-    sentry_sdk.set_tag('is_ci_env', is_ci_env())
-    sentry_sdk.set_tag('is_github_codespace', is_github_codespace())
-    sentry_sdk.set_tag('system_timezone', get_system_timezone())
+    sentry_sdk.set_tag("recce.version", __version__)
+    sentry_sdk.set_tag("platform", sys.platform)
+    sentry_sdk.set_tag("is_ci_env", is_ci_env())
+    sentry_sdk.set_tag("is_github_codespace", is_github_codespace())
+    sentry_sdk.set_tag("system_timezone", get_system_timezone())
 
 
 def get_user_id():
-    return load_user_profile().get('user_id')
+    return load_user_profile().get("user_id")
 
 
 def get_recce_api_token():
-    return load_user_profile().get('api_token')
+    return load_user_profile().get("api_token")
 
 
 def is_anonymous_tracking():
-    return load_user_profile().get('anonymous_tracking', False)
+    return load_user_profile().get("anonymous_tracking", False)
 
 
 def _get_sentry_dns():
-    dns_file = os.path.normpath(os.path.join(os.path.dirname(__file__), 'SENTRY_DNS'))
+    dns_file = os.path.normpath(os.path.join(os.path.dirname(__file__), "SENTRY_DNS"))
     with open(dns_file) as f:
         dns = f.read().strip()
         return dns
 
 
 def _get_sentry_env():
-    if '.dev' in __version__:
-        return 'development'
-    elif re.match(r'^\d+\.\d+\.\d+\.\d{8}[a|b|rc]?.*$', __version__):
-        return 'nightly'
-    elif 'a' in __version__:
-        return 'alpha'
-    elif 'b' in __version__:
-        return 'beta'
-    elif 'rc' in __version__:
-        return 'release-candidate'
-    return 'production'
+    if ".dev" in __version__:
+        return "development"
+    elif re.match(r"^\d+\.\d+\.\d+\.\d{8}[a|b|rc]?.*$", __version__):
+        return "nightly"
+    elif "a" in __version__:
+        return "alpha"
+    elif "b" in __version__:
+        return "beta"
+    elif "rc" in __version__:
+        return "release-candidate"
+    return "production"
 
 
 def _get_api_key():
-    if os.getenv('RECCE_EVENT_API_KEY'):
+    if os.getenv("RECCE_EVENT_API_KEY"):
         # For local testing purpose
-        return os.getenv('RECCE_EVENT_API_KEY')
+        return os.getenv("RECCE_EVENT_API_KEY")
 
-    config_file = os.path.abspath(os.path.join(os.path.dirname(__file__), 'CONFIG'))
+    config_file = os.path.abspath(os.path.join(os.path.dirname(__file__), "CONFIG"))
     try:
         with open(config_file) as fh:
             config = pyml.load(fh)
-            return config.get('event_api_key')
+            return config.get("event_api_key")
     except Exception:
         return None
 
@@ -108,15 +112,15 @@ def _generate_user_profile():
         os.makedirs(RECCE_USER_HOME, exist_ok=True)
     except Exception:
         # TODO: should show warning message but not raise exception
-        print('Please disable command tracking to continue.')
+        print("Please disable command tracking to continue.")
         exit(1)
     if is_github_codespace() is True:
-        salted_name = f'codespace-{get_github_codespace_name()}'
+        salted_name = f"codespace-{get_github_codespace_name()}"
         user_id = hashlib.sha256(salted_name.encode()).hexdigest()
     else:
         user_id = uuid.uuid4().hex
-    with open(RECCE_USER_PROFILE, 'w+') as f:
-        pyml.dump({'user_id': user_id, 'anonymous_tracking': True}, f)
+    with open(RECCE_USER_PROFILE, "w+") as f:
+        pyml.dump({"user_id": user_id, "anonymous_tracking": True}, f)
     return dict(user_id=user_id, anonymous_tracking=True)
 
 
@@ -125,9 +129,9 @@ def load_user_profile():
         if not os.path.exists(RECCE_USER_PROFILE):
             user_profile = _generate_user_profile()
         else:
-            with open(RECCE_USER_PROFILE, 'r') as f:
+            with open(RECCE_USER_PROFILE, "r") as f:
                 user_profile = pyml.load(f)
-                if user_profile.get('user_id') is None:
+                if user_profile.get("user_id") is None:
                     user_profile = _generate_user_profile()
 
         return user_profile
@@ -136,7 +140,7 @@ def load_user_profile():
 def update_user_profile(update_values):
     original = load_user_profile()
     original.update(update_values)
-    with open(RECCE_USER_PROFILE, 'w+') as f:
+    with open(RECCE_USER_PROFILE, "w+") as f:
         pyml.dump(original, f)
     return original
 
@@ -146,10 +150,10 @@ def flush_events(command=None):
 
 
 def should_log_event():
-    with open(RECCE_USER_PROFILE, 'r') as f:
+    with open(RECCE_USER_PROFILE, "r") as f:
         user_profile = pyml.load(f)
     # TODO: default anonymous_tracking to false if field is not present
-    tracking = user_profile.get('anonymous_tracking', False)
+    tracking = user_profile.get("anonymous_tracking", False)
     tracking = tracking and isinstance(tracking, bool)
     if not tracking:
         return False
@@ -166,18 +170,18 @@ def log_event(prop, event_type, **kwargs):
 
     repo = hosting_repo()
     if repo is not None:
-        prop['repository'] = sha256(repo.encode()).hexdigest()
+        prop["repository"] = sha256(repo.encode()).hexdigest()
 
     branch = current_branch()
     if branch is not None:
-        prop['branch'] = sha256(branch.encode()).hexdigest()
+        prop["branch"] = sha256(branch.encode()).hexdigest()
 
     runner = get_runner()
     if runner is not None:
-        prop['runner_type'] = runner
+        prop["runner_type"] = runner
 
-        if runner == 'github codespaces':
-            prop['codespaces_name'] = get_github_codespace_name()
+        if runner == "github codespaces":
+            prop["codespaces_name"] = get_github_codespace_name()
 
     payload = dict(
         **prop,
@@ -191,11 +195,11 @@ def log_api_event(endpoint_name, prop):
         **prop,
         endpoint_name=endpoint_name,
     )
-    log_event(prop, 'api_event')
+    log_event(prop, "api_event")
     _collector.schedule_flush()
 
 
-def log_load_state(command='server', single_env=False):
+def log_load_state(command="server", single_env=False):
     from recce.models import CheckDAO
 
     checks = 0
@@ -213,10 +217,10 @@ def log_load_state(command='server', single_env=False):
     )
 
     if command == "server":
-        prop['single_env'] = single_env
+        prop["single_env"] = single_env
 
-    log_event(prop, 'load_state')
-    if command == 'server':
+    log_event(prop, "load_state")
+    if command == "server":
         _collector.schedule_flush()
 
 
@@ -227,31 +231,29 @@ def log_codespaces_events(command):
         return
 
     user_prop = dict(
-        location=codespace.get('location'),
-        is_prebuild=codespace.get('prebuild', False),
+        location=codespace.get("location"),
+        is_prebuild=codespace.get("prebuild", False),
     )
 
     prop = dict(
-        machine=codespace.get('machine', {}).get('display_name'),
+        machine=codespace.get("machine", {}).get("display_name"),
         codespaces_name=get_github_codespace_name(),
     )
 
     # Codespace created event, send once
-    codespace_created_at = load_user_profile().get('codespace_created_at')
+    codespace_created_at = load_user_profile().get("codespace_created_at")
     if codespace_created_at is None:
-        created_at = datetime.fromisoformat(codespace.get('created_at'))
-        prop['state'] = 'created'
-        _collector.log_event(prop, 'codespace_instance', event_triggered_at=created_at,
-                             user_properties=user_prop)
-        update_user_profile({'codespace_created_at': codespace.get('created_at')})
+        created_at = datetime.fromisoformat(codespace.get("created_at"))
+        prop["state"] = "created"
+        _collector.log_event(prop, "codespace_instance", event_triggered_at=created_at, user_properties=user_prop)
+        update_user_profile({"codespace_created_at": codespace.get("created_at")})
 
     # Codespace available event, send multiple times as start/stop it
     available_at = get_github_codespace_available_at(codespace)
-    if available_at and available_at.isoformat() != load_user_profile().get('codespace_available_at'):
-        prop['state'] = 'available'
-        _collector.log_event(prop, 'codespace_instance', event_triggered_at=available_at,
-                             user_properties=user_prop)
-        update_user_profile({'codespace_available_at': available_at.isoformat()})
+    if available_at and available_at.isoformat() != load_user_profile().get("codespace_available_at"):
+        prop["state"] = "available"
+        _collector.log_event(prop, "codespace_instance", event_triggered_at=available_at, user_properties=user_prop)
+        update_user_profile({"codespace_available_at": available_at.isoformat()})
 
     # Codespace instance event should be flushed immediately
     _collector.send_events()
@@ -259,20 +261,20 @@ def log_codespaces_events(command):
 
 def log_single_env_event():
     prop = dict(
-        action='launch_server',
+        action="launch_server",
     )
-    log_event(prop, '[Experiment] single_environment')
+    log_event(prop, "[Experiment] single_environment")
     _collector.schedule_flush()
 
 
 def log_performance(feature_name: str, metrics: Dict):
     prop = metrics
-    log_event(prop, f'[Performance] {feature_name}')
+    log_event(prop, f"[Performance] {feature_name}")
     _collector.schedule_flush()
 
 
 def capture_exception(e):
-    user_id = load_user_profile().get('user_id')
+    user_id = load_user_profile().get("user_id")
     if is_ci_env() is True:
         user_id = f"{user_id}_CI"
 

recce/event/collector.py

@@ -4,9 +4,8 @@ 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
@@ -17,7 +16,7 @@ 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
 
@@ -35,6 +34,7 @@ class Collector:
 
         # send async thread
         import threading
+
         if self._flush_timer:
             try:
                 self._flush_timer.cancel()
@@ -59,11 +59,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 +98,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
@@ -120,17 +127,17 @@ 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:
             try:
                 o = json.loads(f.read())
                 yield o
@@ -146,9 +153,9 @@ class Collector:
         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 +164,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,9 @@ class TrackCommand(Command):
 
             if recce_context is not None:
                 if recce_context.adapter_type == "dbt":
-                    props['adapter_type'] = 'DBT'
+                    props["adapter_type"] = "DBT"
                 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):