FIX: Fix exception chaining

Author: nmacholl

CHANGELOG.md

@@ -8,6 +8,7 @@
 - Changed `Live.__iter__()` and `Live.__aiter__()` to send the session start message if the session is connected but not started
 - Upgraded `databento-dbn` to 0.7.1
 - Removed `Encoding`, `Compression`, `Schema`, and `SType` enums as they are now exposed by `databento-dbn`
+- Removed exception chaining from exceptions emitted by the library
 
 #### Breaking changes
 - Renamed `func` parameter to `record_callback` for `Live.add_callback` and `Live.add_stream`

databento/common/dbnstore.py

@@ -789,10 +789,9 @@ def replay(self, callback: Callable[[Any], None]) -> None:
         for record in self:
             try:
                 callback(record)
-            except Exception as exc:
+            except Exception:
                 logger.exception(
                     "exception while replaying to user callback",
-                    exc_info=exc,
                 )
                 raise
 

databento/common/enums.py

@@ -65,17 +65,17 @@ def coerced_new(enum: type[M], value: object) -> M:
             )
         try:
             return _new(enum, coerce_fn(value))
-        except ValueError as ve:
+        except ValueError:
             name_to_try = str(value).replace(".", "_").replace("-", "_").upper()
             named = enum._member_map_.get(name_to_try)
             if named is not None:
                 return named
-            enum_values = tuple(value for value in enum._value2member_map_)
+            enum_values = list(value for value in enum._value2member_map_)
 
             raise ValueError(
-                f"value `{value}` is not a member of {enum_type.__name__}. "
-                f"use one of {enum_values}.",
-            ) from ve
+                f"The `{value}` was not a valid value of {enum_type.__name__}"
+                f", was '{value}'. Use any of {enum_values}.",
+            ) from None
 
     setattr(enum_type, "__new__", coerced_new)
 

databento/common/validation.py

@@ -30,11 +30,11 @@ def validate_path(value: PathLike[str] | str, param: str) -> Path:
     """
     try:
         return Path(value)
-    except TypeError as e:
+    except TypeError:
         raise TypeError(
             f"The `{param}` was not a valid path type. "
             "Use any of [str, bytes, os.PathLike].",
-        ) from e
+        ) from None
 
 
 def validate_enum(
@@ -68,16 +68,16 @@ def validate_enum(
     """
     try:
         return enum(value)
-    except ValueError as e:
+    except ValueError:
         if hasattr(enum, "variants"):
             valid = list(map(str, enum.variants()))  # type: ignore [attr-defined]
         else:
             valid = list(map(str, enum))
 
         raise ValueError(
-            f"The `{param}` was not a valid value of {enum}, was '{value}'. "
-            f"Use any of {valid}.",
-        ) from e
+            f"The `{param}` was not a valid value of {enum.__name__}"
+            f", was '{value}'. Use any of {valid}.",
+        ) from None
 
 
 def validate_maybe_enum(

databento/live/client.py

@@ -527,9 +527,9 @@ def block_for_close(
             self.terminate()
             if isinstance(exc, KeyboardInterrupt):
                 raise
-        except Exception as exc:
+        except Exception:
             logger.exception("exception encountered blocking for close")
-            raise BentoError("connection lost") from exc
+            raise BentoError("connection lost") from None
 
     async def wait_for_close(
         self,
@@ -572,9 +572,9 @@ async def wait_for_close(
             self.terminate()
             if isinstance(exc, KeyboardInterrupt):
                 raise
-        except Exception as exc:
+        except Exception:
             logger.exception("exception encountered waiting for close")
-            raise BentoError("connection lost") from exc
+            raise BentoError("connection lost") from None
 
     async def _shutdown(self) -> None:
         """

databento/live/gateway.py

@@ -49,10 +49,10 @@ def parse(cls: type[T], line: str) -> T:
 
         try:
             return cls(**data_dict)
-        except TypeError as type_err:
+        except TypeError:
             raise ValueError(
                 f"`{line.strip()} is not a parsible {cls.__name__}",
-            ) from type_err
+            ) from None
 
     def __str__(self) -> str:
         fields = tuple(map(attrgetter("name"), dataclasses.fields(self)))

databento/live/session.py

@@ -500,15 +500,15 @@ async def _connect_task(
                 ),
                 timeout=CONNECT_TIMEOUT_SECONDS,
             )
-        except asyncio.TimeoutError as exc:
+        except asyncio.TimeoutError:
             raise BentoError(
                 f"Connection to {gateway}:{port} timed out after "
                 f"{CONNECT_TIMEOUT_SECONDS} second(s).",
-            ) from exc
+            ) from None
         except OSError as exc:
             raise BentoError(
-                f"Connection to {gateway}:{port} failed.",
-            ) from exc
+                f"Connection to {gateway}:{port} failed: {exc}",
+            ) from None
 
         logger.debug(
             "connected to %s:%d",
@@ -521,13 +521,13 @@ async def _connect_task(
                 protocol.authenticated,
                 timeout=AUTH_TIMEOUT_SECONDS,
             )
-        except asyncio.TimeoutError as exc:
+        except asyncio.TimeoutError:
             raise BentoError(
                 f"Authentication with {gateway}:{port} timed out after "
                 f"{AUTH_TIMEOUT_SECONDS} second(s).",
-            ) from exc
+            ) from None
         except ValueError as exc:
-            raise BentoError(f"User authentication failed: {str(exc)}") from exc
+            raise BentoError(f"User authentication failed: {str(exc)}") from None
 
         logger.info(
             "authentication with remote gateway completed",

tests/test_release.py

@@ -45,16 +45,16 @@ def test_release_changelog(changelog: str) -> None:
     try:
         versions = list(map(operator.itemgetter(0), releases))
         version_tuples = [tuple(map(int, v.split("."))) for v in versions]
-    except Exception as exc:
+    except Exception:
         # This could happen if we have an irregular version string.
-        raise AssertionError("Failed to parse version from CHANGELOG.md") from exc
+        raise AssertionError("Failed to parse version from CHANGELOG.md")
 
     try:
         date_strings = list(map(operator.itemgetter(1), releases))
         dates = list(map(date.fromisoformat, date_strings))
-    except Exception as exc:
+    except Exception:
         # This could happen if we have TBD as the release date.
-        raise AssertionError("Failed to parse release date from CHANGELOG.md") from exc
+        raise AssertionError("Failed to parse release date from CHANGELOG.md")
 
     # Ensure latest version matches `__version__`
     assert databento.__version__ == versions[0]