crypticorn 2.8.0rc7__py3-none-any.whl → 2.8.0rc9__py3-none-any.whl

crypticorn/__init__.py

@@ -6,9 +6,13 @@ We adhere to [Semantic Versioning](https://semver.org/).
 You can find the full Changelog [below](#changelog).
 """
 
+import warnings
+import logging
 from crypticorn.common.logging import configure_logging
 
-configure_logging("crypticorn")
+warnings.filterwarnings("default", "", DeprecationWarning)
+configure_logging()
+logging.captureWarnings(True)
 
 from crypticorn.client import ApiClient
 

crypticorn/common/__init__.py

@@ -11,5 +11,7 @@ from crypticorn.common.pagination import *
 from crypticorn.common.logging import *
 from crypticorn.common.ansi_colors import *
 from crypticorn.common.middleware import *
+from crypticorn.common.warnings import *
+from crypticorn.common.openapi import *
 from crypticorn.common.router.status_router import router as status_router
 from crypticorn.common.router.admin_router import router as admin_router

crypticorn/common/ansi_colors.py

@@ -1,8 +1,9 @@
 from enum import StrEnum
-from typing import TYPE_CHECKING
 
 
 class AnsiColors(StrEnum):
+    """Provides a collection of ANSI color codes for terminal text formatting, including regular, bright, and bold text colors. Useful for creating colorful and readable console output."""
+
     # Regular Text Colors
     BLACK = "\033[30m"  # black
     RED = "\033[31m"  # red

crypticorn/common/auth.py

@@ -38,8 +38,8 @@ class AuthHandler:
     """
     Middleware for verifying API requests. Verifies the validity of the authentication token, scopes, etc.
 
-    @param base_url: The base URL of the API.
-    @param api_version: The version of the API.
+    :param base_url: The base URL of the API.
+    :param api_version: The version of the API.
     """
 
     def __init__(

crypticorn/common/enums.py

@@ -1,3 +1,5 @@
+"""Defines common enumerations used throughout the codebase for type safety and consistency."""
+
 from enum import StrEnum
 from crypticorn.common.mixins import ValidateEnumMixin, ExcludeEnumMixin
 

crypticorn/common/errors.py

@@ -1,10 +1,12 @@
+"""Comprehensive error handling system defining various API error types, HTTP exceptions, and error content structures."""
+
 from enum import Enum, StrEnum
 from fastapi import status
 from crypticorn.common.mixins import ExcludeEnumMixin, ApiErrorFallback
 
 
 class ApiErrorType(ExcludeEnumMixin, StrEnum):
-    """Type of API error"""
+    """Type of the API error."""
 
     USER_ERROR = "user error"
     """user error by people using our services"""
@@ -17,7 +19,7 @@ class ApiErrorType(ExcludeEnumMixin, StrEnum):
 
 
 class ApiErrorIdentifier(ExcludeEnumMixin, StrEnum):
-    """API error identifiers"""
+    """Unique identifier of the API error."""
 
     ALLOCATION_BELOW_EXPOSURE = "allocation_below_current_exposure"
     ALLOCATION_BELOW_MINIMUM = "allocation_below_min_amount"
@@ -103,7 +105,7 @@ class ApiErrorIdentifier(ExcludeEnumMixin, StrEnum):
 
 
 class ApiErrorLevel(ExcludeEnumMixin, StrEnum):
-    """API error levels"""
+    """Level of the API error."""
 
     ERROR = "error"
     INFO = "info"
@@ -112,7 +114,8 @@ class ApiErrorLevel(ExcludeEnumMixin, StrEnum):
 
 
 class ApiError(ExcludeEnumMixin, Enum, metaclass=ApiErrorFallback):
-    """API error codes. Fallback to UNKNOWN_ERROR for error codes not yet published to PyPI."""
+    # Fallback to UNKNOWN_ERROR for error codes not yet published to PyPI.
+    """Crypticorn API error enumeration."""
 
     ALLOCATION_BELOW_EXPOSURE = (
         ApiErrorIdentifier.ALLOCATION_BELOW_EXPOSURE,
@@ -518,7 +521,7 @@ class ApiError(ExcludeEnumMixin, Enum, metaclass=ApiErrorFallback):
 
 
 class StatusCodeMapper:
-    """Map API errors to HTTP status codes."""
+    """Mapping of API errors to HTTP/Websocket status codes."""
 
     _mapping = {
         # Authentication/Authorization

crypticorn/common/exceptions.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, Any, Literal
+from typing import Optional, Dict, Any
 from enum import StrEnum
 from pydantic import BaseModel, Field
 from fastapi import HTTPException as FastAPIHTTPException, Request, FastAPI
@@ -6,17 +6,20 @@ from fastapi.exceptions import RequestValidationError, ResponseValidationError
 from fastapi.responses import JSONResponse
 from crypticorn.common import ApiError, ApiErrorIdentifier, ApiErrorType, ApiErrorLevel
 import logging
+import json
 
-logger = logging.getLogger(__name__)
+_logger = logging.getLogger("crypticorn")
 
 
-class ExceptionType(StrEnum):
+class _ExceptionType(StrEnum):
+    """The protocol the exception is called from"""
+
     HTTP = "http"
     WEBSOCKET = "websocket"
 
 
 class ExceptionDetail(BaseModel):
-    """This is the detail of the exception. It is used to enrich the exception with additional information by unwrapping the ApiError into its components."""
+    """Exception details returned to the client."""
 
     message: Optional[str] = Field(None, description="An additional error message")
     code: ApiErrorIdentifier = Field(..., description="The unique error code")
@@ -27,14 +30,14 @@ class ExceptionDetail(BaseModel):
 
 
 class ExceptionContent(BaseModel):
-    """This is the detail of the exception. Pass an ApiError to the constructor and an optional human readable message."""
+    """Exception content used when raising an exception."""
 
     error: ApiError = Field(..., description="The unique error code")
     message: Optional[str] = Field(None, description="An additional error message")
     details: Any = Field(None, description="Additional details about the error")
 
     def enrich(
-        self, _type: Optional[ExceptionType] = ExceptionType.HTTP
+        self, _type: Optional[_ExceptionType] = _ExceptionType.HTTP
     ) -> ExceptionDetail:
         return ExceptionDetail(
             message=self.message,
@@ -43,7 +46,7 @@ class ExceptionContent(BaseModel):
             level=self.error.level,
             status_code=(
                 self.error.http_code
-                if _type == ExceptionType.HTTP
+                if _type == _ExceptionType.HTTP
                 else self.error.websocket_code
             ),
             details=self.details,
@@ -53,14 +56,14 @@ class ExceptionContent(BaseModel):
 class HTTPException(FastAPIHTTPException):
     """A custom HTTP exception wrapper around FastAPI's HTTPException.
     It allows for a more structured way to handle errors, with a message and an error code. The status code is being derived from the detail's error.
-        The ApiError class is the source of truth for everything. If the error is not yet implemented, there are fallbacks to avoid errors while testing.
+        The ApiError class is the source of truth. If the error is not yet implemented, there are fallbacks in place.
     """
 
     def __init__(
         self,
         content: ExceptionContent,
         headers: Optional[Dict[str, str]] = None,
-        _type: Optional[ExceptionType] = ExceptionType.HTTP,
+        _type: Optional[_ExceptionType] = _ExceptionType.HTTP,
     ):
         self.content = content
         self.headers = headers
@@ -81,11 +84,11 @@ class WebSocketException(HTTPException):
     def __init__(
         self, content: ExceptionContent, headers: Optional[Dict[str, str]] = None
     ):
-        super().__init__(content, headers, _type=ExceptionType.WEBSOCKET)
+        super().__init__(content, headers, _type=_ExceptionType.WEBSOCKET)
 
     @classmethod
     def from_http_exception(cls, http_exception: HTTPException):
-        """This is a helper method to convert an HTTPException to a WebSocketException."""
+        """Helper method to convert an HTTPException to a WebSocketException."""
         return WebSocketException(
             content=http_exception.content,
             headers=http_exception.headers,
@@ -93,46 +96,47 @@ class WebSocketException(HTTPException):
 
 
 async def general_handler(request: Request, exc: Exception) -> JSONResponse:
-    """This is the default exception handler for all exceptions."""
+    """Default exception handler for all exceptions."""
     body = ExceptionContent(message=str(exc), error=ApiError.UNKNOWN_ERROR)
     res = JSONResponse(
         status_code=body.enrich().status_code,
         content=HTTPException(content=body).detail,
     )
-    logger.error(f"Response validation error: {res}")
+    _logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
     return res
 
 
 async def request_validation_handler(
     request: Request, exc: RequestValidationError
 ) -> JSONResponse:
-    """This is the exception handler for all request validation errors."""
+    """Exception handler for all request validation errors."""
     body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_REQUEST)
     res = JSONResponse(
         status_code=body.enrich().status_code,
         content=HTTPException(content=body).detail,
     )
-    logger.error(f"Response validation error: {res}")
+    _logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
     return res
 
 
 async def response_validation_handler(
     request: Request, exc: ResponseValidationError
 ) -> JSONResponse:
-    """This is the exception handler for all response validation errors."""
+    """Exception handler for all response validation errors."""
     body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_RESPONSE)
     res = JSONResponse(
         status_code=body.enrich().status_code,
         content=HTTPException(content=body).detail,
     )
-    logger.error(f"Response validation error: {res}")
+    _logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
     return res
 
 
 async def http_handler(request: Request, exc: HTTPException) -> JSONResponse:
-    """This is the exception handler for HTTPExceptions. It unwraps the HTTPException and returns the detail in a flat JSON response."""
-    logger.error(f"HTTP error: {exc.detail}")
-    return JSONResponse(status_code=exc.status_code, content=exc.detail)
+    """Exception handler for HTTPExceptions. It unwraps the HTTPException and returns the detail in a flat JSON response."""
+    res = JSONResponse(status_code=exc.status_code, content=exc.detail)
+    _logger.error(f"HTTP error: {json.loads(res.__dict__.get('body'))}")
+    return res
 
 
 def register_exception_handlers(app: FastAPI):

crypticorn/common/logging.py

@@ -1,12 +1,7 @@
 from __future__ import annotations
 
-# shared_logger.py
 import logging
 import sys
-from contextvars import ContextVar
-from contextlib import asynccontextmanager
-import json
-from pydantic import BaseModel
 from enum import StrEnum
 from crypticorn.common.mixins import ValidateEnumMixin
 from crypticorn.common.ansi_colors import AnsiColors as C
@@ -23,6 +18,7 @@ class LogLevel(ValidateEnumMixin, StrEnum):
 
     @classmethod
     def get_color(cls, level: str) -> str:
+        """Get the ansi color based on the log level."""
         if level == cls.DEBUG:
             return C.GREEN_BRIGHT
         elif level == cls.INFO:
@@ -38,10 +34,12 @@ class LogLevel(ValidateEnumMixin, StrEnum):
 
     @staticmethod
     def get_level(level: "LogLevel") -> int:
+        """Get the integer value from a log level name."""
         return logging._nameToLevel.get(level, logging.INFO)
 
     @staticmethod
     def get_name(level: int) -> "LogLevel":
+        """Get the level name from the integer value of a log level."""
         return LogLevel(logging._levelToName.get(level, "INFO"))
 
 
@@ -51,11 +49,10 @@ _LOGFORMAT = (
     f"%(levelcolor)s%(levelname)s{C.RESET} - "
     f"%(message)s"
 )
-_PLAIN_LOGFORMAT = "%(asctime)s - " "%(name)s - " "%(levelname)s - " "%(message)s"
 _DATEFMT = "%Y-%m-%d %H:%M:%S.%f:"
 
 
-class CustomFormatter(logging.Formatter):
+class _CustomFormatter(logging.Formatter):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
@@ -71,7 +68,7 @@ class CustomFormatter(logging.Formatter):
 
 
 def configure_logging(
-    name: str,
+    name: str = None,
     fmt: str = _LOGFORMAT,
     datefmt: str = _DATEFMT,
     stdout_level: int = logging.INFO,
@@ -81,9 +78,16 @@ def configure_logging(
 ) -> None:
     """Configures the logging for the application.
     Run this function as early as possible in the application (for example using the `lifespan` parameter in FastAPI).
-    Then use can use the default `logging.getLogger(__name__)` method to get the logger.
+    Then use can use the default `logging.getLogger(__name__)` method to get the logger (or <name> if you set the name parameter).
+    :param name: The name of the logger. If not provided, the root logger will be used. Use a name if you use multiple loggers in the same application.
+    :param fmt: The format of the log message.
+    :param datefmt: The date format of the log message.
+    :param stdout_level: The level of the log message to be printed to the console.
+    :param file_level: The level of the log message to be written to the file. Only used if `log_file` is provided.
+    :param log_file: The file to write the log messages to.
+    :param filters: A list of filters to apply to the log handlers.
     """
-    logger = logging.getLogger(name)
+    logger = logging.getLogger(name) if name else logging.getLogger()
 
     if logger.handlers:  # clear existing handlers to avoid duplicates
         logger.handlers.clear()
@@ -93,7 +97,7 @@ def configure_logging(
     # Configure stdout handler
     stdout_handler = logging.StreamHandler(sys.stdout)
     stdout_handler.setLevel(stdout_level)
-    stdout_handler.setFormatter(CustomFormatter(fmt=fmt, datefmt=datefmt))
+    stdout_handler.setFormatter(_CustomFormatter(fmt=fmt, datefmt=datefmt))
     for filter in filters:
         stdout_handler.addFilter(filter)
     logger.addHandler(stdout_handler)
@@ -105,11 +109,14 @@ def configure_logging(
             log_file, maxBytes=10 * 1024 * 1024, backupCount=5
         )
         file_handler.setLevel(file_level)
-        file_handler.setFormatter(CustomFormatter(fmt=fmt, datefmt=datefmt))
+        file_handler.setFormatter(_CustomFormatter(fmt=fmt, datefmt=datefmt))
         for filter in filters:
             file_handler.addFilter(filter)
         logger.addHandler(file_handler)
 
+    if name:
+        logger.propagate = False
+
 
 def disable_logging():
     """Disable logging for the crypticorn logger."""

crypticorn/common/middleware.py

@@ -1,7 +1,7 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from crypticorn.common.logging import configure_logging
-import logging
+from contextlib import asynccontextmanager
 
 
 def add_cors_middleware(app: "FastAPI"):
@@ -11,18 +11,18 @@ def add_cors_middleware(app: "FastAPI"):
             "http://localhost:5173",  # vite dev server
             "http://localhost:4173",  # vite preview server
         ],
-        allow_origin_regex="^https:\/\/([a-zA-Z0-9-]+\.)*crypticorn\.(dev|com)\/?$",  # matches (multiple or no) subdomains of crypticorn.dev and crypticorn.com
+        allow_origin_regex="^https://([a-zA-Z0-9-]+.)*crypticorn.(dev|com)/?$",  # matches (multiple or no) subdomains of crypticorn.dev and crypticorn.com
         allow_credentials=True,
         allow_methods=["*"],
         allow_headers=["*"],
     )
 
 
+@asynccontextmanager
 async def default_lifespan(app: FastAPI):
     """Default lifespan for the applications.
     This is used to configure the logging for the application.
     To override this, pass a different lifespan to the FastAPI constructor or call this lifespan within a custom lifespan.
     """
-    configure_logging(__name__)  # for the consuming app
-    logger = logging.getLogger(__name__)
+    configure_logging()
     yield

crypticorn/common/mixins.py

@@ -1,7 +1,9 @@
 from enum import EnumMeta
 import logging
+import warnings
+from crypticorn.common.warnings import CrypticornDeprecatedSince28
 
-logger = logging.getLogger("uvicorn")
+_logger = logging.getLogger("crypticorn")
 
 
 class ValidateEnumMixin:
@@ -35,7 +37,12 @@ class ValidateEnumMixin:
 
 # This Mixin will be removed in a future version. And has no effect from now on
 class ExcludeEnumMixin:
-    """Mixin to exclude enum from OpenAPI schema. We use this to avoid duplicating enums when generating client code from the openapi spec."""
+    """(deprecated) Mixin to exclude enum from OpenAPI schema. We use this to avoid duplicating enums when generating client code from the openapi spec."""
+
+    warnings.warn(
+        "The `ExcludeEnumMixin` class is deprecated. Should be removed from enums inheriting this class.",
+        category=CrypticornDeprecatedSince28,
+    )
 
     @classmethod
     def __get_pydantic_json_schema__(cls, core_schema, handler):
@@ -51,7 +58,7 @@ class ApiErrorFallback(EnumMeta):
         # Let Pydantic/internal stuff pass silently ! fragile
         if name.startswith("__"):
             raise AttributeError(name)
-        logger.warning(
+        _logger.warning(
             f"Unknown enum member '{name}' - update crypticorn package or check for typos"
         )
         return cls.UNKNOWN_ERROR

crypticorn/common/openapi.py

@@ -0,0 +1,11 @@
+default_tags = [
+        {   
+            "name": "Status",
+            "description": "These endpoints contain status operations.",
+        },
+        {   
+            "name": "Admin",
+            "description": "These endpoints contain debugging and monitoring operations. They require admin scopes.",
+        }
+    ]
+

crypticorn/common/pagination.py

@@ -1,3 +1,5 @@
+"""Utilities for handling paginated API responses and cursor-based pagination."""
+
 from typing import Generic, Type, TypeVar, List, Optional, Literal
 from pydantic import BaseModel, Field, model_validator
 

crypticorn/common/router/admin_router.py

@@ -20,10 +20,10 @@ router = APIRouter(tags=["Admin"], prefix="/admin")
 START_TIME = time.time()
 
 
-@router.get("/log-level", status_code=200, operation_id="getLogLevel")
+@router.get("/log-level", status_code=200, operation_id="getLogLevel", deprecated=True)
 async def get_logging_level() -> LogLevel:
     """
-    Get the log level of the server logger.
+    Get the log level of the server logger. Will be removed in a future release.
     """
     return LogLevel.get_name(logging.getLogger().level)
 
@@ -39,7 +39,7 @@ def get_uptime(type: Literal["seconds", "human"] = "seconds") -> str:
 
 
 @router.get("/memory", operation_id="getMemoryUsage", status_code=200)
-def get_memory_usage() -> int:
+def get_memory_usage() -> float:
     """
     Resident Set Size (RSS) in MB — the actual memory used by the process in RAM.
     Represents the physical memory footprint. Important for monitoring real usage.

crypticorn/common/router/status_router.py

@@ -1,12 +1,19 @@
+"""
+This module contains the status router for the API.
+It provides endpoints for checking the status of the API and get the server's time.
+SHOULD ALLOW ACCESS TO THIS ROUTER WITHOUT.
+>>> app.include_router(status_router)
+"""
+
 from datetime import datetime
 from typing import Literal
-from fastapi import APIRouter
+from fastapi import APIRouter, Request
 
 router = APIRouter(tags=["Status"], prefix="")
 
 
 @router.get("/", operation_id="ping")
-async def ping() -> str:
+async def ping(request: Request) -> dict:
     """
     Returns 'OK' if the API is running.
     """

crypticorn/common/scopes.py

@@ -54,7 +54,7 @@ class Scope(StrEnum):
 
     @classmethod
     def admin_scopes(cls) -> list["Scope"]:
-        """Scopes that are only available to admins"""
+        """Scopes that are only available to admins."""
         return [
             cls.WRITE_TRADE_STRATEGIES,
             cls.WRITE_PAY_PRODUCTS,
@@ -64,14 +64,14 @@ class Scope(StrEnum):
 
     @classmethod
     def internal_scopes(cls) -> list["Scope"]:
-        """Scopes that are only available to internal services"""
+        """Scopes that are only available to internal services."""
         return [
             cls.WRITE_TRADE_ACTIONS,
         ]
 
     @classmethod
     def purchaseable_scopes(cls) -> list["Scope"]:
-        """Scopes that can be purchased"""
+        """Scopes that can be purchased."""
         return [
             cls.READ_PREDICTIONS,
         ]

crypticorn/common/urls.py

@@ -3,6 +3,8 @@ from crypticorn.common.enums import ValidateEnumMixin
 
 
 class ApiEnv(StrEnum):
+    """The environment the API is being used with."""
+
     PROD = "prod"
     DEV = "dev"
     LOCAL = "local"
@@ -10,6 +12,8 @@ class ApiEnv(StrEnum):
 
 
 class BaseUrl(StrEnum):
+    """The base URL to connect to the API."""
+
     PROD = "https://api.crypticorn.com"
     DEV = "https://api.crypticorn.dev"
     LOCAL = "http://localhost"
@@ -17,6 +21,7 @@ class BaseUrl(StrEnum):
 
     @classmethod
     def from_env(cls, env: ApiEnv) -> "BaseUrl":
+        """Load the base URL from the API environment."""
         if env == ApiEnv.PROD:
             return cls.PROD
         elif env == ApiEnv.DEV:
@@ -28,10 +33,14 @@ class BaseUrl(StrEnum):
 
 
 class ApiVersion(StrEnum):
+    """Versions to use for the microservice APIs."""
+
     V1 = "v1"
 
 
 class Service(ValidateEnumMixin, StrEnum):
+    """The microservices available to connect to through the API"""
+
     HIVE = "hive"
     KLINES = "klines"
     PAY = "pay"

crypticorn/common/utils.py

@@ -1,11 +1,14 @@
-from typing import Any, Union
+"""General utility functions and helper methods used across the codebase."""
+
+from typing import Any
 from decimal import Decimal
 import string
 import random
-from fastapi import status
-from typing_extensions import deprecated
+import typing_extensions
+import warnings
 
-from crypticorn.common import ApiError, HTTPException, ExceptionContent
+from crypticorn.common.exceptions import ApiError, HTTPException, ExceptionContent
+from crypticorn.common.warnings import CrypticornDeprecatedSince25
 
 
 def throw_if_none(
@@ -33,7 +36,9 @@ def gen_random_id(length: int = 20) -> str:
     return "".join(random.choice(charset) for _ in range(length))
 
 
-@deprecated("Use math.isclose instead. Will be removed in a future version.")
+@typing_extensions.deprecated(
+    "The `is_equal` method is deprecated; use `math.is_close` instead.", category=None
+)
 def is_equal(
     a: float | Decimal,
     b: float | Decimal,
@@ -43,6 +48,10 @@ def is_equal(
     """
     Compare two Decimal numbers for approximate equality.
     """
+    warnings.warn(
+        "The `is_equal` method is deprecated; use `math.is_close` instead.",
+        category=CrypticornDeprecatedSince25,
+    )
     if not isinstance(a, Decimal):
         a = Decimal(str(a))
     if not isinstance(b, Decimal):
@@ -56,13 +65,12 @@ def is_equal(
 
 def optional_import(module_name: str, extra_name: str) -> Any:
     """
-    Import a module optionally.
+    Tries to import a module. Raises `ImportError` if not found with a message to install the extra dependency.
     """
     try:
         return __import__(module_name)
     except ImportError as e:
-        extra = f"[{extra_name}]"
         raise ImportError(
             f"Optional dependency '{module_name}' is required for this feature. "
-            f"Install it with: pip install crypticorn{extra}"
+            f"Install it with: pip install crypticorn[{extra_name}]"
         ) from e

crypticorn/common/warnings.py

@@ -0,0 +1,63 @@
+"""Crypticorn-specific warnings."""
+
+from __future__ import annotations
+
+
+class CrypticornDeprecationWarning(DeprecationWarning):
+    """A Crypticorn specific deprecation warning.
+
+    This warning is raised when using deprecated functionality in Crypticorn. It provides information on when the
+    deprecation was introduced and the expected version in which the corresponding functionality will be removed.
+
+    Attributes:
+        message: Description of the warning.
+        since: Crypticorn version in what the deprecation was introduced.
+        expected_removal: Crypticorn version in what the corresponding functionality expected to be removed.
+    """
+
+    message: str
+    since: tuple[int, int]
+    expected_removal: tuple[int, int]
+
+    def __init__(
+        self,
+        message: str,
+        *args: object,
+        since: tuple[int, int],
+        expected_removal: tuple[int, int] | None = None,
+    ) -> None:
+        super().__init__(message, *args)
+        self.message = message.rstrip(".")
+        self.since = since
+        self.expected_removal = (
+            expected_removal if expected_removal is not None else (since[0] + 1, 0)
+        )
+
+    def __str__(self) -> str:
+        message = (
+            f"{self.message}. Deprecated in Crypticorn v{self.since[0]}.{self.since[1]}"
+            f" to be removed in v{self.expected_removal[0]}.{self.expected_removal[1]}."
+        )
+        return message
+
+
+class CrypticornDeprecatedSince25(CrypticornDeprecationWarning):
+    """A specific `CrypticornDeprecationWarning` subclass defining functionality deprecated since Crypticorn 2.5."""
+
+    def __init__(self, message: str, *args: object) -> None:
+        super().__init__(message, *args, since=(2, 5), expected_removal=(3, 0))
+
+
+class CrypticornDeprecatedSince28(CrypticornDeprecationWarning):
+    """A specific `CrypticornDeprecationWarning` subclass defining functionality deprecated since Crypticorn 2.8."""
+
+    def __init__(self, message: str, *args: object) -> None:
+        super().__init__(message, *args, since=(2, 8), expected_removal=(3, 0))
+
+
+class CrypticornExperimentalWarning(Warning):
+    """A Crypticorn specific experimental functionality warning.
+
+    This warning is raised when using experimental functionality in Crypticorn.
+    It is raised to warn users that the functionality may change or be removed in future versions of Crypticorn.
+    """