transcrypto 2.2.0__tar.gz → 2.3.0__tar.gz

{transcrypto-2.2.0 → transcrypto-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transcrypto
-Version: 2.2.0
+Version: 2.3.0
 Summary: Basic crypto primitives, not intended for actual use, but as a companion to --Criptografia, Métodos e Algoritmos--
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -16,10 +16,10 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Utilities
 Classifier: Topic :: Security :: Cryptography
 Requires-Dist: cryptography (>=46.0)
-Requires-Dist: gmpy2 (>=2.2)
-Requires-Dist: platformdirs (>=4.5)
+Requires-Dist: gmpy2 (>=2.3)
+Requires-Dist: platformdirs (>=4.7)
 Requires-Dist: rich (>=14.3,!=14.3.2)
-Requires-Dist: typer (>=0.21)
+Requires-Dist: typer (>=0.23)
 Requires-Dist: zstandard (>=0.25)
 Project-URL: Changelog, https://github.com/balparda/transcrypto/blob/main/CHANGELOG.md
 Project-URL: Homepage, https://github.com/balparda/transcrypto

{transcrypto-2.2.0 → transcrypto-2.3.0}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "poetry.core.masonry.api"
 [project]
 
 name = "transcrypto"
-version = "2.2.0"  # also update src/transcrypto/__init__.py
+version = "2.3.0"  # also update src/transcrypto/__init__.py
 
 description = "Basic crypto primitives, not intended for actual use, but as a companion to --Criptografia, Métodos e Algoritmos--"
 license = "Apache-2.0"
@@ -59,15 +59,15 @@ license-files = [ "LICENSE" ]
 
 dependencies = [
 
-  "typer>=0.21",   # if this changes, also change: [tool.poetry.dependencies]
+  "typer>=0.23",   # if this changes, also change: [tool.poetry.dependencies]
   "rich>=14.3,!=14.3.2",  # 14.3.2 hangs GitHub CI pipeline
-  "platformdirs>=4.5",
+  "platformdirs>=4.7",
 
   # best place for project dependencies, if possible
   # development-only dependencies go in the [tool.poetry.group.dev.dependencies] section below
 
   "cryptography>=46.0",
-  "gmpy2>=2.2",
+  "gmpy2>=2.3",
   "zstandard>=0.25",
 
 ]
@@ -117,11 +117,11 @@ include = [
 # prefer to add dependencies inside the [project.dependencies] section
 
 python = "^3.12"  # if version changes, remember to change README.md
-typer = { version = "^0.21", extras = ["all"] }
+typer = { version = "^0.23", extras = ["all"] }
 
 [tool.poetry.group.dev.dependencies]
 
-ruff = "~0.14.14"
+ruff = "~0.15.1"
 mypy = "~1.19.1"
 pytest = "^9.0"
 pytest-cov = "^7.0"
@@ -173,7 +173,7 @@ ignore-overlong-task-comments = true
 
 select = [
   "ALL",   # ALL rules --- if too strict comment this out and pick the ones you need below
-#   "E",     # pycodestyle “errors” (basic correctness-ish style checks)
+#   "E",     # pycodestyle "errors" (basic correctness-ish style checks)
 # 	"F",     # pyflakes (unused imports/vars, undefined names, etc.)
 # 	"I",     # isort rules (import sorting)
 # 	"UP",    # pyupgrade (suggest modern Python syntax)
@@ -203,6 +203,7 @@ ignore = [
 
   "E731",     # Do not assign a `lambda` expression, use a `def`
   "FBT001",   # Boolean-typed positional argument in function definition
+  "FBT002",   # Boolean default positional argument in function definition
   "FBT003",   # allows boolean positional value in function call
   "PLR0913",  # Too many arguments in function definition (N > 5)
   "PLR0917",  # Too many positional arguments (N/5)
@@ -238,11 +239,12 @@ preview = true  # if you want new features being previewed
 [tool.mypy]
 
 python_version = "3.12"
-mypy_path = [ "src" ]
+mypy_path = [ "src", "typings" ]
+
+warn_unused_ignores = false  # VSCode always has more to say, so this is important
 
 warn_return_any = true
 warn_unused_configs = true
-warn_unused_ignores = true
 disallow_untyped_defs = true
 no_implicit_optional = true
 warn_redundant_casts = true

{transcrypto-2.2.0 → transcrypto-2.3.0}/src/transcrypto/__init__.py

@@ -3,5 +3,5 @@
 """Basic cryptography primitives implementation."""
 
 __all__: list[str] = ['__author__', '__version__']
-__version__ = '2.2.0'  # remember to also update pyproject.toml
+__version__ = '2.3.0'  # remember to also update pyproject.toml
 __author__ = 'Daniel Balparda <balparda@github.com>'

{transcrypto-2.2.0 → transcrypto-2.3.0}/src/transcrypto/core/hashes.py

@@ -41,11 +41,11 @@ def Hash512(data: bytes, /) -> bytes:
   return hashlib.sha512(data).digest()
 
 
-def FileHash(full_path: str, /, *, digest: str = 'sha256') -> bytes:
+def FileHash(full_path: str | pathlib.Path, /, *, digest: str = 'sha256') -> bytes:
   """SHA-256 hex hash of file on disk. Always a length of 32 bytes (if default digest=='sha256').
 
   Args:
-    full_path (str): Path to existing file on disk
+    full_path (str | pathlib.Path): Path to existing file on disk
     digest (str, optional): Hash method to use, accepts 'sha256' (default) or 'sha512'
 
   Returns:
@@ -61,12 +61,12 @@ def FileHash(full_path: str, /, *, digest: str = 'sha256') -> bytes:
   digest = digest.lower().strip().replace('-', '')  # normalize so we can accept e.g. "SHA-256"
   if digest not in {'sha256', 'sha512'}:
     raise base.InputError(f'unrecognized digest: {digest!r}')
-  full_path = full_path.strip()
-  if not full_path or not pathlib.Path(full_path).exists():
-    raise base.InputError(f'file {full_path!r} not found for hashing')
+  full_path = pathlib.Path(full_path)
+  if not full_path.exists():
+    raise base.InputError(f'file {str(full_path)!r} not found for hashing')
   # compute hash
-  logging.info(f'Hashing file {full_path!r}')
-  with pathlib.Path(full_path).open('rb') as file_obj:
+  logging.info(f'Hashing file {str(full_path)!r}')
+  with full_path.open('rb') as file_obj:
     return hashlib.file_digest(file_obj, digest).digest()
 
 

{transcrypto-2.2.0 → transcrypto-2.3.0}/src/transcrypto/core/key.py

@@ -573,7 +573,7 @@ def Serialize[T](
   python_obj: T,
   /,
   *,
-  file_path: str | None = None,
+  file_path: str | pathlib.Path | None = None,
   compress: int | None = 3,
   encryption_key: Encryptor | None = None,
   silent: bool = False,
@@ -601,7 +601,7 @@ def Serialize[T](
 
   Args:
     python_obj (Any): serializable Python object
-    file_path (str, optional): full path to optionally save the data to
+    file_path (str | pathlib.Path | None, optional): full path to optionally save the data to
     compress (int | None, optional): Compress level before encrypting/saving; -22 ≤ compress ≤ 22;
         None is no compression; default is 3, which is fast, see table above for other values
     encryption_key (Encryptor, optional): if given will encryption_key.Encrypt() data before save
@@ -636,11 +636,12 @@ def Serialize[T](
       if not silent:
         messages.append(f'    {tm_crypto}, {human.HumanizedBytes(len(obj))}')
     # optionally save to disk
+    file_path = pathlib.Path(file_path) if file_path else None
     if file_path is not None:
       with timer.Timer('SAVE', emit_log=False) as tm_save:
-        pathlib.Path(file_path).write_bytes(obj)
+        file_path.write_bytes(obj)
       if not silent:
-        messages.append(f'    {tm_save}, to {file_path!r}')
+        messages.append(f'    {tm_save}, to {str(file_path)!r}')
   # log and return
   if not silent:
     logging.info(f'{tm_all}; parts:\n{"\n".join(messages)}')
@@ -650,7 +651,7 @@ def Serialize[T](
 def DeSerialize[T](  # noqa: C901
   *,
   data: bytes | None = None,
-  file_path: str | None = None,
+  file_path: str | pathlib.Path | None = None,
   decryption_key: Decryptor | None = None,
   silent: bool = False,
   unpickler: abc.Callable[[bytes], T] = UnpickleGeneric,
@@ -668,8 +669,9 @@ def DeSerialize[T](  # noqa: C901
   Args:
     data (bytes | None, optional): if given, use this as binary data string (input);
         if you use this option, `file_path` will be ignored
-    file_path (str | None, optional): if given, use this as file path to load binary data
-        string (input); if you use this option, `data` will be ignored. Defaults to None.
+    file_path (str | pathlib.Path | None, optional): if given, use this as file path to
+        load binary data string (input); if you use this option, `data` will be ignored.
+        Defaults to None.
     decryption_key (Decryptor | None, optional): if given will decryption_key.Decrypt() data before
         decompressing/loading. Defaults to None.
     silent (bool, optional): if True will not log; default is False (will log). Defaults to False.
@@ -689,8 +691,9 @@ def DeSerialize[T](  # noqa: C901
   # test inputs
   if (data is None and file_path is None) or (data is not None and file_path is not None):
     raise base.InputError('you must provide only one of either `data` or `file_path`')
-  if file_path and not pathlib.Path(file_path).exists():
-    raise base.InputError(f'invalid file_path: {file_path!r}')
+  file_path = pathlib.Path(file_path) if file_path else None
+  if file_path is not None and not file_path.exists():
+    raise base.InputError(f'invalid file_path: {str(file_path)!r}')
   if data and len(data) < 4:  # noqa: PLR2004
     raise base.InputError('invalid data: too small')
   # start the pipeline
@@ -698,12 +701,12 @@ def DeSerialize[T](  # noqa: C901
   messages: list[str] = [f'DATA: {human.HumanizedBytes(len(obj))}'] if data and not silent else []
   with timer.Timer('De-Serialization complete', emit_log=False) as tm_all:
     # optionally load from disk
-    if file_path:
+    if file_path is not None:
       assert not obj, 'should never happen: if we have a file obj should be empty'  # noqa: S101
       with timer.Timer('LOAD', emit_log=False) as tm_load:
-        obj = pathlib.Path(file_path).read_bytes()
+        obj = file_path.read_bytes()
       if not silent:
-        messages.append(f'    {tm_load}, {human.HumanizedBytes(len(obj))}, from {file_path!r}')
+        messages.append(f'    {tm_load}, {human.HumanizedBytes(len(obj))}, from {str(file_path)!r}')
     # decrypt, if needed
     if decryption_key is not None:
       with timer.Timer('DECRYPT', emit_log=False) as tm_crypto:

{transcrypto-2.2.0 → transcrypto-2.3.0}/src/transcrypto/utils/base.py

@@ -6,6 +6,8 @@ from __future__ import annotations
 
 import base64
 import codecs
+import pathlib
+import subprocess  # noqa: S404
 from collections import abc
 
 # Data conversion utils
@@ -35,6 +37,10 @@ class InputError(Error):
   """Input exception (TransCrypto)."""
 
 
+class NotFoundError(Error, FileNotFoundError):
+  """File not found (TransCrypto)."""
+
+
 class ImplementationError(Error, NotImplementedError):
   """Feature is not implemented yet (TransCrypto)."""
 
@@ -70,3 +76,45 @@ def RawToBytes(s: str, /) -> bytes:
     s = s[1:-1]
   # decode backslash escapes to code points, then map 0..255 -> bytes
   return codecs.decode(s, 'unicode_escape').encode('latin1')
+
+
+def Run(
+  cmd: list[str],
+  /,
+  *,
+  cwd: pathlib.Path | None = None,
+  env: dict[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+  """Run a command; return the completed process; assert success with useful diagnostics.
+
+  Useful for testing CLI commands where we want to assert success and capture
+  stdout/stderr for diagnostics on failure.
+
+  Args:
+      cmd (list[str]): command
+      cwd (Path | None, optional): Path. Defaults to None.
+      env (dict[str, str] | None, optional): Environment. Defaults to None.
+
+  Raises:
+      AssertionError: invalid return code
+
+  Returns:
+      subprocess.CompletedProcess[str]: result
+
+  """
+  result: subprocess.CompletedProcess[str] = subprocess.run(  # noqa: S603
+    cmd,
+    cwd=str(cwd) if cwd is not None else None,
+    env=env,
+    text=True,
+    capture_output=True,
+    check=False,
+  )
+  if result.returncode != 0:
+    details: str = (
+      f'Command failed (exit={result.returncode}): {cmd}\n\n'
+      f'--- stdout ---\n{result.stdout}\n'
+      f'--- stderr ---\n{result.stderr}\n'
+    )
+    raise AssertionError(details)
+  return result

{transcrypto-2.2.0 → transcrypto-2.3.0}/src/transcrypto/utils/config.py

@@ -7,8 +7,11 @@ from __future__ import annotations
 import logging
 import pathlib
 import shutil
+import sys
 import tempfile
 import threading
+import venv
+import zipfile
 from collections import abc
 
 import platformdirs
@@ -306,3 +309,232 @@ class AppConfig:
       silent=silent,
       unpickler=unpickler,
     )
+
+
+def VenvPaths(venv_dir: pathlib.Path) -> tuple[pathlib.Path, pathlib.Path]:
+  """Return virtual environment paths for python and /bin.
+
+  Useful for testing installed CLIs in a clean environment.
+
+  Args:
+      venv_dir (pathlib.Path): path to venv
+
+  Returns:
+      tuple[Path, Path]: (venv_python, venv_bin_dir)
+
+  """
+  is_win: bool = sys.platform.startswith('win')
+  bin_dir: pathlib.Path = venv_dir / 'Scripts' if is_win else venv_dir / 'bin'
+  return (bin_dir / 'python.exe' if is_win else bin_dir / 'python', bin_dir)
+
+
+def FindConsoleScript(bin_dir: pathlib.Path, name: str) -> pathlib.Path:
+  """Find the installed console script in the venv (platform-specific).
+
+  Useful for testing installed CLIs in a clean environment.
+
+  Args:
+      bin_dir (pathlib.Path): directory containing the console scripts
+      name (str): name of the console script to find
+
+  Returns:
+      pathlib.Path: path to the console script
+
+  Raises:
+      base.NotFoundError: if the console script is not found
+
+  """
+  # go through possible script names based on platform conventions; return the first one that exists
+  for p in (
+    bin_dir / name,  # *nix is typically just the name
+    bin_dir / f'{name}.exe',  # Windows may have .exe/.cmd
+    bin_dir / f'{name}.cmd',
+  ):
+    if p.exists():
+      return p
+  raise base.NotFoundError(f'Could not find console script {name!r} in {bin_dir}')
+
+
+def WheelHasConsoleScripts(wheel: pathlib.Path, scripts: set[str]) -> bool:
+  """Return True if the wheel defines the given console scripts.
+
+  Args:
+      wheel (pathlib.Path): wheel path
+      scripts (set[str]): set of console script names to check for; case sensitive
+
+  Returns:
+      bool: True if all specified console scripts are found in the wheel
+
+  """
+  # open the wheel as a zip file and look for entry_points.txt; read
+  try:
+    with zipfile.ZipFile(wheel) as zf:
+      entry_points: list[str] = [n for n in zf.namelist() if n.endswith('entry_points.txt')]
+      if not entry_points:
+        return False
+      data: str = zf.read(entry_points[0]).decode('utf-8', errors='replace')
+  except (OSError, zipfile.BadZipFile):
+    return False
+  # Minimal parse: ensure the [console_scripts] section contains the required names.
+  in_console_scripts: bool = False
+  found: set[str] = set()
+  for raw_line in data.splitlines():
+    line: str = raw_line.strip()
+    if not line or line.startswith(('#', ';')):
+      continue
+    if line.startswith('[') and line.endswith(']'):
+      in_console_scripts = line == '[console_scripts]'
+      continue
+    if in_console_scripts and '=' in line:
+      name: str = line.split('=', 1)[0].strip()
+      found.add(name)
+  return scripts.issubset(found)
+
+
+def EnsureWheel(repo: pathlib.Path, expected_version: str, scripts: set[str], /) -> pathlib.Path:
+  """Build a wheel if needed; return path to the newest wheel in dist/.
+
+  Args:
+      repo (Path): path to the repository root
+      expected_version (str): expected version string to match in the wheel filename
+      scripts (set[str]): set of console script names to check for; case sensitive
+
+  Raises:
+      base.Error: if no wheel is found after building or not finding couldn't build a wheel
+
+  Returns:
+      Path: path to the newest wheel in dist/
+
+  """
+  dist_dir: pathlib.Path = repo / 'dist'
+  dist_dir.mkdir(exist_ok=True)
+
+  def _NewestWheel() -> pathlib.Path | None:
+    # discover existing wheels
+    wheels: list[pathlib.Path] = sorted(dist_dir.glob('*.whl'), key=lambda p: p.stat().st_mtime)
+    # prefer an existing wheel that matches the current source version; otherwise build a new one.
+    matching: list[pathlib.Path] = [w for w in wheels if f'-{expected_version}-' in w.name]
+    if matching:
+      newest: pathlib.Path = matching[-1]
+      # if a stale wheel exists (e.g., built before console scripts were configured), rebuild.
+      if WheelHasConsoleScripts(newest, scripts):
+        return newest
+    return None
+
+  # try to find an existing wheel
+  wheel: pathlib.Path | None = _NewestWheel()
+  if wheel is not None:
+    return wheel  # found
+  # not found: build a new wheel
+  poetry: str | None = shutil.which('poetry')
+  if poetry is None:
+    raise base.Error('`poetry` not found on PATH; cannot build wheel')
+  base.Run([poetry, 'build', '-f', 'wheel'], cwd=repo)
+  # now we must have a wheel!
+  wheel = _NewestWheel()
+  if wheel is not None:
+    return wheel  # found
+  raise base.Error(f'Wheel build succeeded but no `.whl` found in {str(dist_dir)!r}')
+
+
+def EnsureAndInstallWheel(
+  repository_root_dir: pathlib.Path,
+  temporary_dir: pathlib.Path,
+  expected_version: str,
+  scripts: set[str],
+  /,
+) -> tuple[pathlib.Path, pathlib.Path]:
+  """Ensure wheel exists (build if needed), create a `venv`, install the wheel.
+
+  Args:
+      repository_root_dir (pathlib.Path): path to the repository root
+      temporary_dir (pathlib.Path): path to a temporary directory to use for the venv
+      expected_version (str): expected version string to match in the wheel filename
+      scripts (set[str]): set of console script names to check for; case sensitive
+
+  Returns:
+      tuple[pathlib.Path, pathlib.Path]: (venv_python, venv_bin_dir)
+
+  Raises:
+      base.InputError: if the wheel cannot be found or built, if the venv cannot be created,
+          or if the wheel cannot be installed into the venv
+
+  """
+  # check to make sure directories exist, then ensure wheel exists (build if needed)
+  if not repository_root_dir.is_dir() or not temporary_dir.is_dir():
+    raise base.InputError('`repository_root_dir` and `temporary_dir` must be existing directories')
+  if not scripts or not expected_version:
+    raise base.InputError('`expected_version` and `scripts` must be non-empty')
+  wheel: pathlib.Path = EnsureWheel(repository_root_dir, expected_version, scripts)
+  # create an isolated venv (not using Poetry's .venv on purpose)
+  venv_dir: pathlib.Path = temporary_dir / 'venv'
+  venv.EnvBuilder(with_pip=True, clear=True).create(venv_dir)
+  venv_python: pathlib.Path
+  venv_bin_dir: pathlib.Path
+  venv_python, venv_bin_dir = VenvPaths(venv_dir)
+  # install the wheel into the venv
+  base.Run([str(venv_python), '-m', 'pip', 'install', '--upgrade', 'pip'])
+  base.Run([str(venv_python), '-m', 'pip', 'install', str(wheel)])
+  return (venv_python, venv_bin_dir)
+
+
+def EnsureConsoleScriptsPrintExpectedVersion(
+  venv_python: pathlib.Path, venv_bin_dir: pathlib.Path, expected_version: str, scripts: set[str], /
+) -> dict[str, pathlib.Path]:
+  """Ensure the console scripts print the expected version; return their paths.
+
+  Useful for testing installed CLIs in a clean environment.
+
+  Args:
+      venv_python (pathlib.Path): path to the venv python executable
+      venv_bin_dir (pathlib.Path): directory containing the console scripts
+      expected_version (str): expected version string to match in the console script output
+      scripts (set[str]): set of console script names to check for; case sensitive
+
+  Returns:
+      dict[str, pathlib.Path]: mapping of console script name to its path,
+          including a 'python' key for the venv python executable
+
+  Raises:
+      base.Error: a console script does not print the expected version or if script is not found
+
+  """
+  cli_paths: dict[str, pathlib.Path] = {}
+  for script in scripts:
+    cli: pathlib.Path = FindConsoleScript(venv_bin_dir, script)
+    result = base.Run([str(cli), '--version'])
+    if (actual := result.stdout.strip()) != expected_version:
+      raise base.Error(
+        f'Console script {script!r} did not print version {expected_version!r}; got {actual!r}'
+      )
+    cli_paths[script] = cli
+  cli_paths['python'] = venv_python
+  return cli_paths
+
+
+def CallGetConfigDirFromVEnv(venv_python: pathlib.Path, app_name: str) -> pathlib.Path:
+  """Call a Python command in the venv to get the config dir path for the given app name.
+
+  Args:
+      venv_python (pathlib.Path): path to the venv python executable
+      app_name (str): The name of the application.
+
+  Returns:
+      pathlib.Path: the config dir path returned by the command
+
+  Raises:
+      base.InputError: if the venv python executable does not exist or if `app_name` is empty
+
+  """
+  if not venv_python.exists():
+    raise base.InputError(f'venv python not found at {str(venv_python)!r}')
+  if not app_name:
+    raise base.InputError('`app_name` must be a non-empty string')
+  r2 = base.Run(
+    [
+      str(venv_python),
+      '-c',
+      f'from transcrypto.utils import config; print(config.GetConfigDir("{app_name}"))',
+    ]
+  )
+  return pathlib.Path(r2.stdout.strip())

{transcrypto-2.2.0 → transcrypto-2.3.0}/src/transcrypto/utils/stats.py

@@ -22,13 +22,15 @@ _LANCZOS_COEFF: tuple[float, ...] = (
   9.9843695780195716e-6,
   1.5056327351493116e-7,
 )
-_TINY: float = 1e-30
-_NSG: abc.Callable[[float], float] = (
-  lambda z: _TINY if abs(z) < _TINY else z  # numerical stability guard
+TINY: float = 1e-30
+NSG: abc.Callable[[float], float] = (
+  lambda z: TINY if abs(z) < TINY else z  # numerical stability guard
 )
+IS_EQUAL: abc.Callable[[float, float], bool] = lambda a, b: abs(a - b) < TINY
 _BETA_INCOMPLETE_MAX_ITER: int = 200
 _BETA_INCOMPLETE_TOL: float = 1e-14
 _STUDENT_SMALL: float = 1e-12
+IS_STUDENT_EQUAL: abc.Callable[[float, float], bool] = lambda a, b: abs(a - b) < _STUDENT_SMALL
 
 
 def GammaLanczos(z: float, /) -> float:
@@ -87,7 +89,7 @@ def BetaIncompleteCF(a: float, b: float, x: float, /) -> float:
   qap: float = a + 1.0
   qam: float = a - 1.0
   c: float = 1.0
-  d: float = 1.0 / _NSG(1.0 - qab * x / qap)
+  d: float = 1.0 / NSG(1.0 - qab * x / qap)
   h: float = d
   aa: float
   delta: float
@@ -96,11 +98,11 @@ def BetaIncompleteCF(a: float, b: float, x: float, /) -> float:
     m2 = 2 * m
     # even step
     aa = m * (b - m) * x / ((qam + m2) * (a + m2))
-    c, d = _NSG(1.0 + aa / c), 1.0 / _NSG(1.0 + aa * d)
+    c, d = NSG(1.0 + aa / c), 1.0 / NSG(1.0 + aa * d)
     h *= d * c
     # odd step
     aa = -(a + m) * (qab + m) * x / ((a + m2) * (qap + m2))
-    c, d = _NSG(1.0 + aa / c), 1.0 / _NSG(1.0 + aa * d)
+    c, d = NSG(1.0 + aa / c), 1.0 / NSG(1.0 + aa * d)
     delta = d * c
     h *= delta
     if abs(delta - 1.0) < _BETA_INCOMPLETE_TOL:
@@ -133,12 +135,12 @@ def BetaIncomplete(a: float, b: float, x: float, /) -> float:
       x > (a + 1) / (a + b + 2).
 
   """
-  if x < 0.0 or x > 1.0:
-    raise base.InputError(f'x must be in [0, 1], got {x}')
-  if x == 0.0:
+  if IS_EQUAL(x, 0.0):
     return 0.0
-  if x == 1.0:
+  if IS_EQUAL(x, 1.0):
     return 1.0
+  if x < 0.0 or x > 1.0:
+    raise base.InputError(f'x must be in [0, 1], got {x}')
   log_beta: float = math.lgamma(a) + math.lgamma(b) - math.lgamma(a + b)
   front: float = math.exp(math.log(x) * a + math.log(1.0 - x) * b - log_beta) / a
   if x < (a + 1.0) / (a + b + 2.0):
@@ -197,7 +199,7 @@ def StudentTPPF(q: float, df: float, /) -> float:
   if not 0.0 < q < 1.0:
     raise base.InputError(f'q must be in (0, 1), got {q}')
   # Special case: q=0.5 is exactly 0 by symmetry
-  if q == 0.5:  # noqa: PLR2004
+  if IS_EQUAL(q, 0.5):
     return 0.0
   # Initial guess using inverse normal approximation (Abramowitz & Stegun 26.2.23)
   if q < 0.5:  # noqa: PLR2004
@@ -206,9 +208,7 @@ def StudentTPPF(q: float, df: float, /) -> float:
   else:
     sign = 1.0
     p = 1.0 - q
-  # Protect against log(0) when p is very close to 0
-  p = max(p, 1e-300)
-  t_approx: float = math.sqrt(-2.0 * math.log(p))
+  t_approx: float = math.sqrt(-2.0 * math.log(NSG(p)))  # protect against log(0) for tiny p
   c0 = 2.515517
   c1 = 0.802853
   c2 = 0.010328
@@ -230,9 +230,9 @@ def StudentTPPF(q: float, df: float, /) -> float:
       - math.lgamma(df / 2)
       - ((df + 1) / 2) * math.log(1 + x0**2 / df)
     )
-    pdf_val: float = _NSG(math.exp(log_pdf))
+    pdf_val: float = NSG(math.exp(log_pdf))
     x1: float = x0 - (cdf_val - q) / pdf_val
-    if abs(x1 - x0) < _STUDENT_SMALL:
+    if IS_STUDENT_EQUAL(x1, x0):
       return x1
     x0 = x1
   return x0  # pragma: no cover - Newton-Raphson always converges for t-distribution