libephemeris 0.1.6__py3-none-any.whl

libephemeris/__init__.py

@@ -0,0 +1,151 @@
+from .constants import *
+from .time_utils import swe_julday, swe_revjul, swe_deltat
+from .planets import (
+    swe_calc_ut,
+    swe_calc,
+    swe_get_ayanamsa_ut,
+    swe_get_ayanamsa,
+    swe_set_sid_mode,
+)
+from .houses import swe_houses, swe_houses_ex, swe_house_name
+from .state import set_topo as swe_set_topo, set_ephe_path as swe_set_ephe_path
+from .crossing import swe_solcross_ut, swe_mooncross_ut, swe_cross_ut
+from .utils import difdeg2n
+from .fixed_stars import swe_fixstar_ut
+
+# =============================================================================
+# PYSWISSEPH-COMPATIBLE FUNCTION ALIASES (without swe_ prefix)
+# =============================================================================
+# pyswisseph uses function names without the swe_ prefix
+# These aliases provide 100% API compatibility with pyswisseph
+
+# Time functions
+julday = swe_julday
+revjul = swe_revjul
+deltat = swe_deltat
+
+# Planet calculation
+calc_ut = swe_calc_ut
+calc = swe_calc
+
+# Houses
+houses = swe_houses
+houses_ex = swe_houses_ex
+house_name = swe_house_name
+
+# Ayanamsa (sidereal)
+get_ayanamsa_ut = swe_get_ayanamsa_ut
+get_ayanamsa = swe_get_ayanamsa
+set_sid_mode = swe_set_sid_mode
+
+# Observer location
+set_topo = swe_set_topo
+set_ephe_path = swe_set_ephe_path
+
+# Fixed Stars
+fixstar_ut = swe_fixstar_ut
+
+# Crossings
+solcross_ut = swe_solcross_ut
+mooncross_ut = swe_mooncross_ut
+
+
+# Helper function to pre-calculate positions for Arabic parts
+def swe_calc_angles(jd_ut: float, lat: float, lon: float):
+    """
+    Pre-calculate and cache astrological angles and planet positions
+    for use with Arabic parts.
+
+    Args:
+        jd_ut: Julian Day (UT)
+        lat: Latitude (degrees)
+        lon: Longitude (degrees)
+
+    Returns:
+        Dictionary with calculated positions
+    """
+    from .state import set_angles_cache
+    from .angles import calc_angles
+
+    # Set observer location
+    swe_set_topo(lon, lat, 0)
+
+    # Calculate angles
+    angles_dict = calc_angles(jd_ut, lat, lon)
+    
+    # Calculate and add planet positions for Arabic parts
+    from .constants import SE_SUN, SE_MOON, SE_MERCURY, SE_VENUS
+    
+    sun_pos, _ = swe_calc_ut(jd_ut, SE_SUN, 0)
+    moon_pos, _ = swe_calc_ut(jd_ut, SE_MOON, 0)
+    mercury_pos, _ = swe_calc_ut(jd_ut, SE_MERCURY, 0)
+    venus_pos, _ = swe_calc_ut(jd_ut, SE_VENUS, 0)
+    
+    angles_dict['Sun'] = sun_pos[0]
+    angles_dict['Moon'] = moon_pos[0]
+    angles_dict['Mercury'] = mercury_pos[0]
+    angles_dict['Venus'] = venus_pos[0]
+    
+    # Cache for Arabic parts
+    set_angles_cache(angles_dict)
+    
+    return angles_dict
+
+# Helper for Arabic parts
+from .arabic_parts import calc_all_arabic_parts
+
+# Constants (planet IDs, flags, sidereal modes)
+from .constants import *
+
+__version__ = "0.1.0"
+__author__ = "Giacomo Battaglia"
+__license__ = "LGPL-3.0"
+
+__all__ = [
+    # Time functions (both swe_ and non-prefixed aliases)
+    "swe_julday",
+    "julday",
+    "swe_revjul",
+    "revjul",
+    "swe_deltat",
+    "deltat",
+    # Planet calculation
+    "swe_calc_ut",
+    "calc_ut",
+    "swe_calc",
+    "calc",
+    "swe_get_planet_name",
+    # Houses
+    "swe_houses",
+    "houses",
+    "swe_houses_ex",
+    "houses_ex",
+    "swe_house_pos",
+    "swe_house_name",
+    # Ayanamsa (sidereal)
+    "swe_set_sid_mode",
+    "set_sid_mode",
+    "swe_get_ayanamsa_ut",
+    "get_ayanamsa_ut",
+    "swe_get_ayanamsa",
+    "get_ayanamsa",
+    "swe_get_ayanamsa_name",
+    # Observer location
+    "swe_set_topo",
+    "set_topo",
+    "swe_set_ephe_path",
+    "set_ephe_path",
+    # Crossings
+    "swe_solcross_ut",
+    "solcross_ut",
+    "swe_mooncross_ut",
+    "mooncross_ut",
+    "swe_cross_ut",
+    # Utilities
+    "difdeg2n",
+    # Helpers
+    "calc_all_arabic_parts",
+    # Fixed Stars
+    "swe_fixstar_ut",
+    "fixstar_ut",
+]

libephemeris/angles.py

@@ -0,0 +1,106 @@
+"""
+Astrological angles and chart points for libephemeris.
+
+This module calculates the primary astrological angles:
+- Ascendant (ASC): Ecliptic degree rising on eastern horizon  
+- Midheaven (MC): Ecliptic degree culminating on meridian
+- Descendant (DSC): Western horizon point (ASC + 180°)
+- Imum Coeli (IC): Lower meridian (MC + 180°)
+- Vertex: Intersection of prime vertical with western ecliptic
+- Equatorial Ascendant: Equator crossing eastern horizon
+
+All angles require observer geographic location (swe_set_topo).
+Calculations are based on spherical astronomy and house system cusps.
+
+Note:
+    Angles are independent of house system choice (though computed via houses).
+    They represent fundamental horizon/meridian intersections with the ecliptic.
+"""
+
+from typing import Dict
+from .constants import (
+    SE_ASCENDANT,
+    SE_MC,
+    SE_DESCENDANT,
+    SE_IC,
+    SE_VERTEX,
+    SE_ANTIVERTEX,
+)
+from .houses import swe_houses
+
+
+def calc_angles(jd_ut: float, lat: float, lon: float) -> Dict[str, float]:
+    """
+    Calculate all astrological angles for a given time and location.
+    
+    Args:
+        jd_ut: Julian Day in Universal Time (UT1)
+        lat: Geographic latitude in degrees (North positive)
+        lon: Geographic longitude in degrees (East positive)
+        
+    Returns:
+        Dict[str, float]: Dictionary mapping angle names to ecliptic longitudes:
+            - "Ascendant": Rising degree on eastern horizon
+            - "MC": Midheaven (culminating degree)
+            - "ARMC": Right Ascension of MC in degrees
+            - "Vertex": Prime vertical intersection (west)
+            - "Equatorial_Ascendant": Equator on eastern horizon
+            - "Descendant": Setting degree (Asc + 180°)
+            - "IC": Lower meridian (MC + 180°)
+            - "AntiVertex": Prime vertical intersection (east)
+            
+    Note:
+        Uses Placidus house system internally, but angle values are
+        system-independent. They are purely geometric intersections.
+        
+        Angles are sensitive to observer location. Polar regions may
+        have undefined values for some angles.
+    """
+    _, ascmc = swe_houses(jd_ut, lat, lon, ord("P"))
+
+    return {
+        "Ascendant": ascmc[0],
+        "MC": ascmc[1],
+        "ARMC": ascmc[2],
+        "Vertex": ascmc[3],
+        "Equatorial_Ascendant": ascmc[4] if len(ascmc) > 4 else 0.0,
+        "Descendant": (ascmc[0] + 180.0) % 360.0,
+        "IC": (ascmc[1] + 180.0) % 360.0,
+        "AntiVertex": (ascmc[3] + 180.0) % 360.0,
+    }
+
+
+def get_angle_value(angle_id: int, jd_ut: float, lat: float, lon: float) -> float:
+    """
+    Get ecliptic longitude for a specific angle.
+    
+    Args:
+        angle_id: Angle identifier constant (SE_ASCENDANT, SE_MC, etc.)
+        jd_ut: Julian Day in Universal Time (UT1)
+        lat: Geographic latitude in degrees (North positive)
+        lon: Geographic longitude in degrees (East positive)
+        
+    Returns:
+        float: Ecliptic longitude of the angle in degrees (0-360)
+               Returns 0.0 if angle_id is not recognized
+               
+    Example:
+        >>> asc = get_angle_value(SE_ASCENDANT, jd, 41.9, 12.5)
+        >>> mc = get_angle_value(SE_MC, jd, 41.9, 12.5)
+    """
+    angles = calc_angles(jd_ut, lat, lon)
+
+    angle_map = {
+        SE_ASCENDANT: "Ascendant",
+        SE_MC: "MC",
+        SE_DESCENDANT: "Descendant",
+        SE_IC: "IC",
+        SE_VERTEX: "Vertex",
+        SE_ANTIVERTEX: "AntiVertex",
+    }
+
+    if angle_id in angle_map:
+        return angles[angle_map[angle_id]]
+
+    return 0.0
+

libephemeris/arabic_parts.py

@@ -0,0 +1,232 @@
+"""
+Arabic Parts (Lots) calculations for libephemeris.
+
+Arabic Parts are classical astrological points calculated from combinations
+of planetary positions and angles. They represent specific life areas and
+are used in Hellenistic, Medieval, and modern astrology.
+
+Formulas follow traditional methods from:
+- Dorotheus of Sidon (1st century CE)
+- Vettius Valens (2nd century CE)  
+- Al-Biruni "Book of Instruction" (11th century)
+- Robert Schmidt translations (Project Hindsight)
+
+Standard formula structure: ASC + [Point A] - [Point B]
+Many parts have day/night variations for sect consideration.
+
+Supported Parts:
+- Part of Fortune (Pars Fortunae): Body, health, material success
+- Part of Spirit (Pars Spiritus): Soul, intellect, spiritual matters
+- Part of Love (Pars Amoris/Eros): Romance, desire, relationships
+- Part of Faith (Pars Fidei): Belief, religion, trust
+"""
+
+from typing import Dict
+from .constants import (
+    SE_PARS_FORTUNAE,
+    SE_PARS_SPIRITUS,
+    SE_PARS_AMORIS,
+    SE_PARS_FIDEI,
+)
+
+
+def calc_arabic_part_of_fortune(
+    asc: float, sun: float, moon: float, is_diurnal: bool = True
+) -> float:
+    """
+    Calculate Part of Fortune (Pars Fortunae / Lot of Fortune).
+    
+    The most important Arabic Part, representing body, health, and material fortune.
+    
+    Formula (Vettius Valens, Al-Biruni):
+        - Day chart (Sun above horizon): ASC + Moon - Sun
+        - Night chart (Sun below horizon): ASC + Sun - Moon
+        
+    Args:
+        asc: Ascendant (ecliptic) longitude in degrees
+        sun: Sun ecliptic longitude in degrees
+        moon: Moon ecliptic longitude in degrees
+        is_diurnal: True if day chart (Sun above horizon), False if night
+        
+    Returns:
+        float: Part of Fortune ecliptic longitude in degrees (0-360)
+        
+    Note:
+        The formula reflects sect: in day charts, emphasize the Moon (nocturnal);
+        in night charts, emphasize the Sun (diurnal). This balances opposites.
+        
+        Some modern astrologers use only the day formula regardless of sect.
+        This implementation follows classical tradition.
+    """
+    if is_diurnal:
+        lot = (asc + moon - sun) % 360.0
+    else:
+        lot = (asc + sun - moon) % 360.0
+
+    return lot
+
+
+def calc_arabic_part_of_spirit(
+    asc: float, sun: float, moon: float, is_diurnal: bool = True
+) -> float:
+    """
+    Calculate Part of Spirit (Pars Spiritus / Lot of Spirit / Daimon).
+    
+    Represents the soul, intellect, character, and spiritual development.
+    
+    Formula (opposite of Part of Fortune by sect):
+        - Day chart: ASC + Sun - Moon
+        - Night chart: ASC + Moon - Sun
+        
+    Args:
+        asc: Ascendant longitude in degrees
+        sun: Sun longitude in degrees
+        moon: Moon longitude in degrees
+        is_diurnal: True if day chart
+        
+    Returns:
+        float: Part of Spirit longitude in degrees (0-360)
+        
+    Note:
+        In Hellenistic astrology (Valens), Part of Spirit was called "Daimon"
+        and considered complementary to Fortune. Together they represent
+        body (Fortune) and soul (Spirit).
+    """
+    if is_diurnal:
+        lot = (asc + sun - moon) % 360.0
+    else:
+        lot = (asc + moon - sun) % 360.0
+
+    return lot
+
+
+def calc_arabic_part_of_love(asc: float, venus: float, sun: float) -> float:
+    """
+    Calculate Part of Love (Pars Amoris / Lot of Eros).
+    
+    Represents romantic love, desire, sexual attraction, and relationships.
+    
+    Formula: ASC + Venus - Sun
+    
+    Args:
+        asc: Ascendant longitude in degrees
+        venus: Venus longitude in degrees
+        sun: Sun longitude in degrees
+        
+    Returns:
+        float: Part of Love longitude in degrees (0-360)
+        
+    Note:
+        This formula is not sect-dependent. Venus naturally signifies
+        love and attraction in all charts. Some medieval sources use
+        alternate formulas with Moon or Mars for male/female charts.
+    """
+    return (asc + venus - sun) % 360.0
+
+
+def calc_arabic_part_of_faith(asc: float, mercury: float, moon: float) -> float:
+    """
+    Calculate Part of Faith (Pars Fidei / Lot of Faith).
+    
+    Represents religious belief, trust, philosophical convictions.
+    
+    Formula: ASC + Mercury - Moon
+    
+    Args:
+        asc: Ascendant longitude in degrees
+        mercury: Mercury longitude in degrees
+        moon: Moon longitude in degrees
+        
+    Returns:
+        float: Part of Faith longitude in degrees (0-360)
+        
+    Note:
+        Mercury represents rational thought and communication of beliefs.
+        The Moon represents unconscious reception and emotional faith.
+        This part shows how one's beliefs are communicated/manifested.
+    """
+    return (asc + mercury - moon) % 360.0
+
+
+def is_day_chart(sun_lon: float, asc: float) -> bool:
+    """
+    Determine if chart is diurnal (day) or nocturnal (night) based on sect.
+    
+    A chart is diurnal if the Sun is above the horizon (in houses 7-12).
+    
+    Args:
+        sun_lon: Sun ecliptic longitude in degrees (0-360)
+        asc: Ascendant ecliptic longitude in degrees (0-360)
+        
+    Returns:
+        bool: True if day chart (Sun above horizon), False if night chart
+        
+    Algorithm:
+        The horizon runs from Ascendant (east) to Descendant (west).
+        Points between ASC and DSC (going counter-clockwise through MC)
+        are above the horizon. This is the zodiacal arc from ASC to ASC+180°.
+        
+    Note:
+        This is a simplified 2D calculation using ecliptic longitude only.
+        It assumes the horizon plane intersects the ecliptic at ASC/DSC.
+        
+        For extreme latitudes or precise calculations, use 3D horizon
+        coordinates (altitude/azimuth). This method is traditional and
+        sufficient for most astrological purposes.
+    """
+    desc = (asc + 180.0) % 360.0
+
+    # Check if Sun is in upper hemisphere (ASC to DSC counter-clockwise)
+    if asc < desc:
+        # Normal case: e.g., ASC=0°, DSC=180°
+        return asc <= sun_lon <= desc
+    else:
+        # Wrapped case: e.g., ASC=350°, DSC=170°
+        # Sun is above if >= ASC (e.g., 350-360°) OR <= DSC (e.g., 0-170°)
+        return sun_lon >= asc or sun_lon <= desc
+
+
+def calc_all_arabic_parts(positions: Dict[str, float]) -> Dict[str, float]:
+    """
+    Calculate all standard Arabic parts from a position dictionary.
+    
+    Args:
+        positions: Dictionary of celestial positions in ecliptic longitude degrees.
+                  Required keys: 'Asc', 'Sun', 'Moon', 'Mercury', 'Venus'
+                  All values should be in range 0-360 degrees.
+                  
+    Returns:
+        Dict[str, float]: Dictionary mapping part names to longitudes:
+            - "Pars_Fortunae": Part of Fortune
+            - "Pars_Spiritus": Part of Spirit
+            - "Pars_Amoris": Part of Love
+            - "Pars_Fidei": Part of Faith
+            
+    Example:
+        >>> positions = {
+        ...     'Asc': 15.5, 'Sun': 120.0, 'Moon': 240.0,
+        ...     'Mercury': 130.0, 'Venus': 110.0
+        ... }
+        >>> parts = calc_all_arabic_parts(positions)
+        >>> print(parts['Pars_Fortunae'])
+        135.5
+        
+    Note:
+        Missing keys will default to 0.0. Ensure all required positions
+        are present for accurate results.
+    """
+    asc = positions.get("Asc", 0.0)
+    sun = positions.get("Sun", 0.0)
+    moon = positions.get("Moon", 0.0)
+    mercury = positions.get("Mercury", 0.0)
+    venus = positions.get("Venus", 0.0)
+
+    is_diurnal = is_day_chart(sun, asc)
+
+    return {
+        "Pars_Fortunae": calc_arabic_part_of_fortune(asc, sun, moon, is_diurnal),
+        "Pars_Spiritus": calc_arabic_part_of_spirit(asc, sun, moon, is_diurnal),
+        "Pars_Amoris": calc_arabic_part_of_love(asc, venus, sun),
+        "Pars_Fidei": calc_arabic_part_of_faith(asc, mercury, moon),
+    }
+