kerykeion 3.1.1__py3-none-any.whl → 5.1.9__py3-none-any.whl

kerykeion/fetch_geonames.py

@@ -1,43 +1,60 @@
+# -*- coding: utf-8 -*-
 """
-    This is part of Kerykeion (C) 2022 Giacomo Battaglia
+Author: Giacomo Battaglia
+Copyright: (C) 2025 Kerykeion Project
+License: AGPL-3.0
 """
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 
-import logging
+
+from logging import getLogger
+from datetime import timedelta
+from os import getenv
+from pathlib import Path
+from typing import Optional, Union
+
 from requests import Request
 from requests_cache import CachedSession
-from typing import Union
 
-logging.basicConfig(
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.INFO
-)
+
+logger = getLogger(__name__)
+
+
+DEFAULT_GEONAMES_CACHE_NAME = Path("cache") / "kerykeion_geonames_cache"
+GEONAMES_CACHE_ENV_VAR = "KERYKEION_GEONAMES_CACHE_NAME"
 
 
 class FetchGeonames:
     """
-    Class to handle requests to the geonames API
+    Class to handle requests to the GeoNames API for location data and timezone information.
+
+    This class provides cached access to the GeoNames API to retrieve location coordinates,
+    timezone information, and other geographical data for astrological calculations.
 
     Args:
-    city_name (str): Name of the city
-    country_code (str): Two letters country code
-    username (str, optional): Geonames username, defaults to "century.boy".
-    logger (Union[logging.Logger, None], optional): 
-        Optional logger, defaults to None. If none provided creates one.
+        city_name: Name of the city to search for.
+        country_code: Two-letter country code (ISO 3166-1 alpha-2).
+        username: GeoNames username for API access, defaults to "century.boy".
+        cache_expire_after_days: Number of days to cache responses, defaults to 30.
+        cache_name: Optional path (directory or filename stem) used by requests-cache.
+            Defaults to "cache/kerykeion_geonames_cache" and may also be overridden
+            via the environment variable ``KERYKEION_GEONAMES_CACHE_NAME`` or by
+            calling :meth:`FetchGeonames.set_default_cache_name`.
     """
 
+    default_cache_name: Path = DEFAULT_GEONAMES_CACHE_NAME
+
     def __init__(
-        self, city_name: str,
+        self,
+        city_name: str,
         country_code: str,
         username: str = "century.boy",
-        logger: Union[logging.Logger, None] = None
+        cache_expire_after_days=30,
+        cache_name: Optional[Union[str, Path]] = None,
     ):
-
         self.session = CachedSession(
-            cache_name='cache/kerykeion_geonames_cache',
-            backend='sqlite',
-            expire_after=86400
+            cache_name=str(self._resolve_cache_name(cache_name)),
+            backend="sqlite",
+            expire_after=timedelta(days=cache_expire_after_days),
         )
 
         self.username = username
@@ -45,111 +62,138 @@ class FetchGeonames:
         self.country_code = country_code
         self.base_url = "http://api.geonames.org/searchJSON"
         self.timezone_url = "http://api.geonames.org/timezoneJSON"
-        self.__logger = logger or logging.getLogger(self.__class__.__name__)
+
+    @classmethod
+    def set_default_cache_name(cls, cache_name: Union[str, Path]) -> None:
+        """Override the default cache name used when none is provided."""
+
+        cls.default_cache_name = Path(cache_name)
+
+    @classmethod
+    def _resolve_cache_name(cls, cache_name: Optional[Union[str, Path]]) -> Path:
+        """Return the resolved cache name applying overrides in priority order."""
+
+        if cache_name is not None:
+            return Path(cache_name)
+
+        env_override = getenv(GEONAMES_CACHE_ENV_VAR)
+        if env_override:
+            return Path(env_override)
+
+        return cls.default_cache_name
 
     def __get_timezone(self, lat: Union[str, float, int], lon: Union[str, float, int]) -> dict[str, str]:
         """
-        Get the timezone for a given latitude and longitude
+        Get timezone information for a given latitude and longitude.
+
+        Args:
+            lat: Latitude coordinate.
+            lon: Longitude coordinate.
+
+        Returns:
+            dict: Timezone data including timezone string and cache status.
         """
         # Dictionary that will be returned:
         timezone_data = {}
 
-        params = {
-            "lat": lat,
-            "lng": lon,
-            "username": self.username
-        }
+        params = {"lat": lat, "lng": lon, "username": self.username}
 
-        prepared_request = Request(
-            "GET", self.timezone_url, params=params).prepare()
-        self.__logger.debug(
-            f"Requesting data from geonames timezones: {prepared_request.url}")
+        prepared_request = Request("GET", self.timezone_url, params=params).prepare()
+        logger.debug("GeoNames timezone lookup url=%s", prepared_request.url)
 
         try:
             response = self.session.send(prepared_request)
             response_json = response.json()
 
         except Exception as e:
-            self.__logger.error(f"Error fetching {self.timezone_url}: {e}")
+            logger.error("GeoNames timezone request failed for %s: %s", self.timezone_url, e)
             return {}
 
         try:
-            timezone_data['timezonestr'] = response_json['timezoneId']
+            timezone_data["timezonestr"] = response_json["timezoneId"]
 
         except Exception as e:
-            self.__logger.error(
-                f"Error serializing data maybe wrong username? Details: {e}")
+            logger.error("GeoNames timezone payload missing expected keys: %s", e)
             return {}
 
-        if hasattr(response, 'from_cache'):
-            timezone_data['from_tz_cache'] = response.from_cache
+        if hasattr(response, "from_cache"):
+            timezone_data["from_tz_cache"] = response.from_cache  # type: ignore
 
         return timezone_data
 
     def __get_contry_data(self, city_name: str, country_code: str) -> dict[str, str]:
         """
-        Get the city data *whitout timezone* for a given city and country name
+        Get city location data without timezone for a given city and country.
+
+        Args:
+            city_name: Name of the city to search for.
+            country_code: Two-letter country code.
+
+        Returns:
+            dict: City location data excluding timezone information.
         """
         # Dictionary that will be returned:
         city_data_whitout_tz = {}
 
         params = {
             "q": city_name,
-            "contry": country_code,
+            "country": country_code,
             "username": self.username,
             "maxRows": 1,
-            "style": "FULL"
+            "style": "SHORT",
+            "featureClass": ["A", "P"],
         }
 
-        prepared_request = Request(
-            "GET", self.base_url, params=params).prepare()
-        self.__logger.debug(
-            f"Requesting data from geonames basic: {prepared_request.url}")
+        prepared_request = Request("GET", self.base_url, params=params).prepare()
+        logger.debug("GeoNames search url=%s", prepared_request.url)
 
         try:
             response = self.session.send(prepared_request)
+            response.raise_for_status()
             response_json = response.json()
+            logger.debug("GeoNames search response: %s", response_json)
 
         except Exception as e:
-            self.__logger.error(f"Error in fetching {self.base_url}: {e}")
+            logger.error("GeoNames search request failed for %s: %s", self.base_url, e)
             return {}
 
         try:
-            city_data_whitout_tz['name'] = response_json['geonames'][0]['name']
-            city_data_whitout_tz['lat'] = response_json['geonames'][0]['lat']
-            city_data_whitout_tz['lng'] = response_json['geonames'][0]['lng']
-            city_data_whitout_tz['countryCode'] = response_json['geonames'][0]['countryCode']
+            city_data_whitout_tz["name"] = response_json["geonames"][0]["name"]
+            city_data_whitout_tz["lat"] = response_json["geonames"][0]["lat"]
+            city_data_whitout_tz["lng"] = response_json["geonames"][0]["lng"]
+            city_data_whitout_tz["countryCode"] = response_json["geonames"][0]["countryCode"]
 
         except Exception as e:
-            self.__logger.error(
-                f"Error serializing data maybe wrong username? Details: {e}")
+            logger.error("GeoNames search payload missing expected keys: %s", e)
             return {}
 
-        if hasattr(response, 'from_cache'):
-            city_data_whitout_tz['from_country_cache'] = response.from_cache
+        if hasattr(response, "from_cache"):
+            city_data_whitout_tz["from_country_cache"] = response.from_cache  # type: ignore
 
         return city_data_whitout_tz
 
     def get_serialized_data(self) -> dict[str, str]:
         """
-        Returns all the data necessary for the Kerykeion calculation.        
+        Returns all the data necessary for the Kerykeion calculation.
 
         Returns:
             dict[str, str]: _description_
         """
-        city_data_response = self.__get_contry_data(
-            self.city_name, self.country_code)
+        city_data_response = self.__get_contry_data(self.city_name, self.country_code)
         try:
-            timezone_response = self.__get_timezone(
-                city_data_response['lat'], city_data_response['lng'])
+            timezone_response = self.__get_timezone(city_data_response["lat"], city_data_response["lng"])
 
         except Exception as e:
-            self.__logger.error(f"Error in fetching timezone: {e}")
+            logger.error("Unable to fetch timezone details: %s", e)
             return {}
 
         return {**timezone_response, **city_data_response}
 
 
 if __name__ == "__main__":
-    geonames = FetchGeonames("Roma", "IT")
+    """Run a tiny demonstration when executing the module directly."""
+    from kerykeion.utilities import setup_logging as configure_logging
+
+    configure_logging("debug")
+    geonames = FetchGeonames("Montichiari", "IT")
     print(geonames.get_serialized_data())

kerykeion/house_comparison/__init__.py

@@ -0,0 +1,6 @@
+
+from .house_comparison_factory import HouseComparisonFactory
+
+__all__ = [
+    "HouseComparisonFactory",
+]

kerykeion/house_comparison/house_comparison_factory.py

@@ -0,0 +1,103 @@
+"""
+House Comparison Factory Module
+
+Provides factory class for house comparison analysis between astrological subjects.
+Enables bidirectional analysis of astrological point placements in house systems.
+
+Author: Giacomo Battaglia
+Copyright: (C) 2025 Kerykeion Project
+License: AGPL-3.0
+"""
+
+from kerykeion.house_comparison.house_comparison_utils import calculate_points_in_reciprocal_houses
+from typing import Union
+from kerykeion.settings.config_constants import DEFAULT_ACTIVE_POINTS
+from kerykeion.schemas.kr_models import HouseComparisonModel
+from kerykeion.astrological_subject_factory import AstrologicalSubjectFactory
+from kerykeion.schemas import AstrologicalSubjectModel, PlanetReturnModel
+from kerykeion.schemas.kr_literals import AstrologicalPoint
+
+
+class HouseComparisonFactory:
+    """
+    Factory for creating house comparison analyses between two astrological subjects.
+
+    Analyzes placement of astrological points from one subject within the house system
+    of another subject, performing bidirectional analysis for synastry studies and
+    subject comparisons. Supports both natal subjects and planetary return subjects.
+
+    Attributes:
+        first_subject: First astrological subject (natal or return subject)
+        second_subject: Second astrological subject (natal or return subject)
+        active_points: List of astrological points to include in analysis
+
+    Example:
+        >>> natal_chart = AstrologicalSubjectFactory.from_birth_data(
+        ...     "Person A", 1990, 5, 15, 10, 30, "Rome", "IT"
+        ... )
+        >>> partner_chart = AstrologicalSubjectFactory.from_birth_data(
+        ...     "Person B", 1992, 8, 23, 14, 45, "Milan", "IT"
+        ... )
+        >>> factory = HouseComparisonFactory(natal_chart, partner_chart)
+        >>> comparison = factory.get_house_comparison()
+
+    """
+    def __init__(self,
+                 first_subject: Union["AstrologicalSubjectModel", "PlanetReturnModel"],
+                 second_subject: Union["AstrologicalSubjectModel", "PlanetReturnModel"],
+                active_points: list[AstrologicalPoint] = DEFAULT_ACTIVE_POINTS,
+
+        ):
+        """
+        Initialize the house comparison factory.
+
+        Args:
+            first_subject: First astrological subject for comparison
+            second_subject: Second astrological subject for comparison
+            active_points: List of astrological points to include in analysis.
+                          Defaults to standard active points.
+
+        Note:
+            Both subjects must have valid house system data for accurate analysis.
+        """
+        self.first_subject = first_subject
+        self.second_subject = second_subject
+        self.active_points = active_points
+
+    def get_house_comparison(self) -> "HouseComparisonModel":
+        """
+        Generate bidirectional house comparison analysis between the two subjects.
+
+        Calculates where each active astrological point from one subject falls within
+        the house system of the other subject, and vice versa.
+
+        Returns:
+            HouseComparisonModel: Model containing:
+                - first_subject_name: Name of the first subject
+                - second_subject_name: Name of the second subject
+                - first_points_in_second_houses: First subject's points in second subject's houses
+                - second_points_in_first_houses: Second subject's points in first subject's houses
+
+        Note:
+            Analysis scope is determined by the active_points list. Only specified
+            points will be included in the results.
+        """
+        first_points_in_second_houses = calculate_points_in_reciprocal_houses(self.first_subject, self.second_subject, self.active_points)
+        second_points_in_first_houses = calculate_points_in_reciprocal_houses(self.second_subject, self.first_subject, self.active_points)
+
+        return HouseComparisonModel(
+            first_subject_name=self.first_subject.name,
+            second_subject_name=self.second_subject.name,
+            first_points_in_second_houses=first_points_in_second_houses,
+            second_points_in_first_houses=second_points_in_first_houses,
+        )
+
+
+if __name__ == "__main__":
+    natal_chart = AstrologicalSubjectFactory.from_birth_data("Person A", 1990, 5, 15, 10, 30, "Rome", "IT")
+    partner_chart = AstrologicalSubjectFactory.from_birth_data("Person B", 1992, 8, 23, 14, 45, "Milan", "IT")
+
+    factory = HouseComparisonFactory(natal_chart, partner_chart)
+    comparison = factory.get_house_comparison()
+
+    print(comparison.model_dump_json(indent=4))

kerykeion/house_comparison/house_comparison_utils.py

@@ -0,0 +1,126 @@
+"""
+House Comparison Utilities
+
+Utility functions for calculating house placement relationships between astrological subjects.
+Provides core calculation logic for determining where points from one subject fall within
+another subject's house system.
+
+Author: Giacomo Battaglia
+Copyright: (C) 2025 Kerykeion Project
+License: AGPL-3.0
+"""
+
+from kerykeion.schemas.kr_models import AstrologicalSubjectModel, PlanetReturnModel, PointInHouseModel
+from kerykeion.schemas.kr_literals import AstrologicalPoint
+from kerykeion.settings.config_constants import DEFAULT_ACTIVE_POINTS
+from kerykeion.utilities import get_planet_house, get_house_number
+from typing import Union
+
+
+def calculate_points_in_reciprocal_houses(
+    point_subject: Union[AstrologicalSubjectModel, PlanetReturnModel],
+    house_subject: Union[AstrologicalSubjectModel, PlanetReturnModel],
+    active_points: list[AstrologicalPoint] = DEFAULT_ACTIVE_POINTS,
+) -> list[PointInHouseModel]:
+    """
+    Calculate house placements of one subject's points within another subject's house system.
+
+    Analyzes where each astrological point from the point_subject falls within the
+    house structure of the house_subject. Creates detailed mapping including both
+    the point's original house position and its projected house placement.
+
+    Args:
+        point_subject: Subject whose astrological points are being analyzed
+        house_subject: Subject whose house system provides the projection framework
+        active_points: List of astrological points to include in the analysis.
+                      Defaults to standard active points configuration.
+
+    Returns:
+        list[PointInHouseModel]: List of point placement models containing detailed
+                                information about each point's house relationships,
+                                including original and projected house positions.
+
+    Note:
+        Only processes points that exist in both the point_subject's active_points
+        and the provided active_points list. Points with None values are skipped.
+
+    Example:
+        >>> points_in_houses = calculate_points_in_reciprocal_houses(
+        ...     natal_chart, partner_chart, ["Sun", "Moon"]
+        ... )
+        >>> sun_placement = points_in_houses[0]  # Assuming Sun is first
+        >>> print(f"Sun falls in house: {sun_placement.projected_house_name}")
+    """
+    points_in_houses: list[PointInHouseModel] = []
+
+    # List of points to consider
+    celestial_points = []
+
+    for point in point_subject.active_points:
+        if point not in active_points:
+            continue
+
+        point_obj = getattr(point_subject, point.lower())
+        if point_obj is not None:
+            celestial_points.append(point_obj)
+
+    # Ordered list of house cusps degrees for house_subject
+    house_cusps = [
+        house_subject.first_house.abs_pos,
+        house_subject.second_house.abs_pos,
+        house_subject.third_house.abs_pos,
+        house_subject.fourth_house.abs_pos,
+        house_subject.fifth_house.abs_pos,
+        house_subject.sixth_house.abs_pos,
+        house_subject.seventh_house.abs_pos,
+        house_subject.eighth_house.abs_pos,
+        house_subject.ninth_house.abs_pos,
+        house_subject.tenth_house.abs_pos,
+        house_subject.eleventh_house.abs_pos,
+        house_subject.twelfth_house.abs_pos,
+    ]
+
+    # Ordered list of house cusps degrees for point_subject
+    point_subject_house_cusps = [
+        point_subject.first_house.abs_pos,
+        point_subject.second_house.abs_pos,
+        point_subject.third_house.abs_pos,
+        point_subject.fourth_house.abs_pos,
+        point_subject.fifth_house.abs_pos,
+        point_subject.sixth_house.abs_pos,
+        point_subject.seventh_house.abs_pos,
+        point_subject.eighth_house.abs_pos,
+        point_subject.ninth_house.abs_pos,
+        point_subject.tenth_house.abs_pos,
+        point_subject.eleventh_house.abs_pos,
+        point_subject.twelfth_house.abs_pos,
+    ]
+
+    # For each point, determine which house it falls in
+    for point in celestial_points:
+        if point is None:
+            continue
+
+        point_degree = point.abs_pos
+        house_name = get_planet_house(point_degree, house_cusps)
+        house_number = get_house_number(house_name)
+
+        # Find which house the point is in its own chart (point_subject)
+        point_owner_house_name = get_planet_house(point_degree, point_subject_house_cusps)
+        point_owner_house_number = get_house_number(point_owner_house_name)
+
+        point_in_house = PointInHouseModel(
+            point_name=point.name,
+            point_degree=point.position,
+            point_sign=point.sign,
+            point_owner_name=point_subject.name,
+            point_owner_house_name=point_owner_house_name,
+            point_owner_house_number=point_owner_house_number,
+            projected_house_number=house_number,
+            projected_house_name=house_name,
+            projected_house_owner_name=house_subject.name,
+        )
+
+        points_in_houses.append(point_in_house)
+
+    return points_in_houses

kerykeion/kr_types/__init__.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""
+Backward compatibility module for Kerykeion v4.x imports.
+
+DEPRECATED: This module will be removed in Kerykeion v6.0.
+Please update your imports:
+    OLD: from kerykeion.kr_types import ...
+    NEW: from kerykeion.schemas import ...
+"""
+import warnings
+
+# Issue deprecation warning when this module is imported
+warnings.warn(
+    "The 'kerykeion.kr_types' module is deprecated and will be removed in v6.0. "
+    "Please update your imports to use 'kerykeion.schemas' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+# Re-export everything from schemas for backward compatibility
+from kerykeion.schemas import *  # noqa: F401, F403
+from kerykeion.schemas.kerykeion_exception import *  # noqa: F401, F403
+from kerykeion.schemas.kr_literals import *  # noqa: F401, F403
+from kerykeion.schemas.kr_models import *  # noqa: F401, F403
+from kerykeion.schemas.settings_models import *  # noqa: F401, F403
+from kerykeion.schemas.chart_template_model import *  # noqa: F401, F403
+
+__all__ = [
+    # Re-export from schemas
+    "KerykeionException",
+    # kr_literals
+    "ZodiacType",
+    "Sign",
+    "SignNumbers",
+    "AspectMovementType",
+    "Houses",
+    "HouseNumbers",
+    "AstrologicalPoint",
+    "Element",
+    "Quality",
+    "ChartType",
+    "PointType",
+    "LunarPhaseEmoji",
+    "LunarPhaseName",
+    "SiderealMode",
+    "HousesSystemIdentifier",
+    "PerspectiveType",
+    "SignsEmoji",
+    "KerykeionChartTheme",
+    "KerykeionChartLanguage",
+    "RelationshipScoreDescription",
+    "CompositeChartType",
+    "AspectName",
+    # kr_models
+    "AstrologicalSubjectModel",
+    "CompositeSubjectModel",
+    "KerykeionPointModel",
+    "AspectModel",
+    "ActiveAspect",
+    "SingleChartAspectsModel",
+    "DualChartAspectsModel",
+    "ElementDistributionModel",
+    "QualityDistributionModel",
+    "SingleChartDataModel",
+    "DualChartDataModel",
+    # settings_models
+    "KerykeionSettingsModel",
+    # chart_template_model
+    "ChartTemplateModel",
+]

kerykeion/kr_types/chart_template_model.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+Backward compatibility module for chart_template_model.
+
+DEPRECATED: This module will be removed in Kerykeion v6.0.
+Please update your imports:
+    OLD: from kerykeion.kr_types.chart_template_model import ...
+    NEW: from kerykeion.schemas.chart_template_model import ...
+"""
+import warnings
+
+warnings.warn(
+    "The 'kerykeion.kr_types.chart_template_model' module is deprecated and will be removed in v6.0. "
+    "Please update your imports to use 'kerykeion.schemas.chart_template_model' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+# Re-export everything from schemas.chart_template_model for backward compatibility
+from kerykeion.schemas.chart_template_model import *  # noqa: F401, F403

kerykeion/kr_types/kerykeion_exception.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+Backward compatibility module for kerykeion_exception.
+
+DEPRECATED: This module will be removed in Kerykeion v6.0.
+Please update your imports:
+    OLD: from kerykeion.kr_types.kerykeion_exception import ...
+    NEW: from kerykeion.schemas.kerykeion_exception import ...
+"""
+import warnings
+
+warnings.warn(
+    "The 'kerykeion.kr_types.kerykeion_exception' module is deprecated and will be removed in v6.0. "
+    "Please update your imports to use 'kerykeion.schemas.kerykeion_exception' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+# Re-export everything from schemas.kerykeion_exception for backward compatibility
+from kerykeion.schemas.kerykeion_exception import *  # noqa: F401, F403

kerykeion/kr_types/kr_literals.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+Backward compatibility module for kr_literals.
+
+DEPRECATED: This module will be removed in Kerykeion v6.0.
+Please update your imports:
+    OLD: from kerykeion.kr_types.kr_literals import ...
+    NEW: from kerykeion.schemas.kr_literals import ...
+"""
+import warnings
+
+warnings.warn(
+    "The 'kerykeion.kr_types.kr_literals' module is deprecated and will be removed in v6.0. "
+    "Please update your imports to use 'kerykeion.schemas.kr_literals' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+# Re-export everything from schemas.kr_literals for backward compatibility
+from kerykeion.schemas.kr_literals import *  # noqa: F401, F403

kerykeion/kr_types/kr_models.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+Backward compatibility module for kr_models.
+
+DEPRECATED: This module will be removed in Kerykeion v6.0.
+Please update your imports:
+    OLD: from kerykeion.kr_types.kr_models import ...
+    NEW: from kerykeion.schemas.kr_models import ...
+"""
+import warnings
+
+warnings.warn(
+    "The 'kerykeion.kr_types.kr_models' module is deprecated and will be removed in v6.0. "
+    "Please update your imports to use 'kerykeion.schemas.kr_models' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+# Re-export everything from schemas.kr_models for backward compatibility
+from kerykeion.schemas.kr_models import *  # noqa: F401, F403

kerykeion/kr_types/settings_models.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+Backward compatibility module for settings_models.
+
+DEPRECATED: This module will be removed in Kerykeion v6.0.
+Please update your imports:
+    OLD: from kerykeion.kr_types.settings_models import ...
+    NEW: from kerykeion.schemas.settings_models import ...
+"""
+import warnings
+
+warnings.warn(
+    "The 'kerykeion.kr_types.settings_models' module is deprecated and will be removed in v6.0. "
+    "Please update your imports to use 'kerykeion.schemas.settings_models' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+# Re-export everything from schemas.settings_models for backward compatibility
+from kerykeion.schemas.settings_models import *  # noqa: F401, F403