Add horoscope-api, synastry, and backend services
- horoscope-api: Swiss Ephemeris natal charts, timezone/place resolution, POST /v1/natal and POST /v1/synastry - backend: users with roles, email/password and Google login, saved charts, synastries and invites, analyses with credit ledger, public shares, admin - shared crates: astro-engine, db (migrations), horoscope-client, service-kit - docker-compose with postgres, legacy Java project for reference Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
@@ -0,0 +1,343 @@
|
||||
//! [`Ephemeris`] implementation backed by the Swiss Ephemeris C library.
|
||||
//!
|
||||
//! The C library keeps process-wide state (ephemeris path, sidereal mode,
|
||||
//! observer position, open files), so all calls go through one global lock.
|
||||
//! A chart needs a few dozen calls of microseconds each, so the lock is not a
|
||||
//! bottleneck for an HTTP service.
|
||||
|
||||
use std::ffi::{CStr, CString};
|
||||
use std::os::raw::c_char;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::{Mutex, MutexGuard, OnceLock};
|
||||
|
||||
use swisseph_sys as sys;
|
||||
|
||||
use crate::angle::normalize;
|
||||
use crate::engine::{
|
||||
BodyState, EngineError, Ephemeris, EphemerisInfo, Frame, GeoPosition, HouseResult, Obliquity, Result,
|
||||
};
|
||||
use crate::types::{Ayanamsa, Body, HouseSystem};
|
||||
|
||||
static LOCK: Mutex<()> = Mutex::new(());
|
||||
static EPHE_PATH: OnceLock<PathBuf> = OnceLock::new();
|
||||
|
||||
pub struct SwissEphemeris {
|
||||
precise_years: Option<(i32, i32)>,
|
||||
version: String,
|
||||
}
|
||||
|
||||
impl SwissEphemeris {
|
||||
/// Initializes the library with the directory holding the `*.se1` files.
|
||||
/// The library is process-global: only one path can be used per process.
|
||||
pub fn new(ephe_dir: impl AsRef<Path>) -> Result<Self> {
|
||||
let dir = ephe_dir.as_ref().to_path_buf();
|
||||
if !dir.is_dir() {
|
||||
return Err(EngineError::Unavailable(format!("ephemeris directory {} does not exist", dir.display())));
|
||||
}
|
||||
let first = EPHE_PATH.get_or_init(|| dir.clone());
|
||||
if *first != dir {
|
||||
return Err(EngineError::Unavailable(format!(
|
||||
"Swiss Ephemeris already initialized with {}",
|
||||
first.display()
|
||||
)));
|
||||
}
|
||||
let c_path = CString::new(dir.to_string_lossy().as_bytes())
|
||||
.map_err(|_| EngineError::Unavailable("ephemeris path contains a NUL byte".into()))?;
|
||||
let version = {
|
||||
let _guard = lock();
|
||||
let mut buf = [0 as c_char; sys::AS_MAXCH];
|
||||
// SAFETY: valid NUL-terminated path; buffers sized AS_MAXCH as required.
|
||||
unsafe {
|
||||
sys::swe_set_ephe_path(c_path.as_ptr());
|
||||
sys::swe_version(buf.as_mut_ptr());
|
||||
}
|
||||
c_string(&buf)
|
||||
};
|
||||
Ok(Self { precise_years: planet_file_coverage(&dir), version })
|
||||
}
|
||||
}
|
||||
|
||||
fn lock() -> MutexGuard<'static, ()> {
|
||||
// A panic while holding the lock cannot leave the C state inconsistent in
|
||||
// a way that matters for subsequent independent calls.
|
||||
LOCK.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
|
||||
}
|
||||
|
||||
fn c_string(buf: &[c_char]) -> String {
|
||||
// SAFETY: the library always NUL-terminates within AS_MAXCH; the buffer is
|
||||
// zero-initialized so a terminator exists even if nothing was written.
|
||||
unsafe { CStr::from_ptr(buf.as_ptr()) }.to_string_lossy().into_owned()
|
||||
}
|
||||
|
||||
/// Year range covered by the planetary files (`sepl_18.se1` = 1800..2399,
|
||||
/// `seplm06.se1` = 600 BC..1 BC, ...).
|
||||
fn planet_file_coverage(dir: &Path) -> Option<(i32, i32)> {
|
||||
let mut range: Option<(i32, i32)> = None;
|
||||
for entry in std::fs::read_dir(dir).ok()?.flatten() {
|
||||
let name = entry.file_name().to_string_lossy().into_owned();
|
||||
let Some(rest) = name.strip_prefix("sepl").and_then(|r| r.strip_suffix(".se1")) else { continue };
|
||||
let (negative, digits) = match rest.strip_prefix('m') {
|
||||
Some(d) => (true, d),
|
||||
None => (false, rest.trim_start_matches('_')),
|
||||
};
|
||||
let Ok(century) = digits.parse::<i32>() else { continue };
|
||||
let start = if negative { -century * 100 } else { century * 100 };
|
||||
let end = start + 599;
|
||||
range = Some(match range {
|
||||
Some((lo, hi)) => (lo.min(start), hi.max(end)),
|
||||
None => (start, end),
|
||||
});
|
||||
}
|
||||
range
|
||||
}
|
||||
|
||||
fn body_id(body: Body) -> i32 {
|
||||
match body {
|
||||
Body::Sun => sys::SE_SUN,
|
||||
Body::Moon => sys::SE_MOON,
|
||||
Body::Mercury => sys::SE_MERCURY,
|
||||
Body::Venus => sys::SE_VENUS,
|
||||
Body::Mars => sys::SE_MARS,
|
||||
Body::Jupiter => sys::SE_JUPITER,
|
||||
Body::Saturn => sys::SE_SATURN,
|
||||
Body::Uranus => sys::SE_URANUS,
|
||||
Body::Neptune => sys::SE_NEPTUNE,
|
||||
Body::Pluto => sys::SE_PLUTO,
|
||||
Body::MeanNode => sys::SE_MEAN_NODE,
|
||||
Body::TrueNode => sys::SE_TRUE_NODE,
|
||||
Body::MeanLilith => sys::SE_MEAN_APOG,
|
||||
Body::TrueLilith => sys::SE_OSCU_APOG,
|
||||
Body::Chiron => sys::SE_CHIRON,
|
||||
Body::Ceres => sys::SE_CERES,
|
||||
Body::Pallas => sys::SE_PALLAS,
|
||||
Body::Juno => sys::SE_JUNO,
|
||||
Body::Vesta => sys::SE_VESTA,
|
||||
}
|
||||
}
|
||||
|
||||
fn sid_mode(ayanamsa: Ayanamsa) -> i32 {
|
||||
match ayanamsa {
|
||||
Ayanamsa::Lahiri => sys::SE_SIDM_LAHIRI,
|
||||
Ayanamsa::FaganBradley => sys::SE_SIDM_FAGAN_BRADLEY,
|
||||
Ayanamsa::Raman => sys::SE_SIDM_RAMAN,
|
||||
Ayanamsa::Krishnamurti => sys::SE_SIDM_KRISHNAMURTI,
|
||||
Ayanamsa::DeLuce => sys::SE_SIDM_DELUCE,
|
||||
Ayanamsa::Yukteshwar => sys::SE_SIDM_YUKTESHWAR,
|
||||
Ayanamsa::TrueCitra => sys::SE_SIDM_TRUE_CITRA,
|
||||
Ayanamsa::GalacticCenter0Sag => sys::SE_SIDM_GALCENT_0SAG,
|
||||
}
|
||||
}
|
||||
|
||||
fn house_code(system: HouseSystem) -> u8 {
|
||||
match system {
|
||||
HouseSystem::Placidus => b'P',
|
||||
HouseSystem::Koch => b'K',
|
||||
HouseSystem::Porphyry => b'O',
|
||||
HouseSystem::Regiomontanus => b'R',
|
||||
HouseSystem::Campanus => b'C',
|
||||
HouseSystem::Equal => b'E',
|
||||
HouseSystem::WholeSign => b'W',
|
||||
HouseSystem::Alcabitius => b'B',
|
||||
HouseSystem::Morinus => b'M',
|
||||
HouseSystem::Topocentric => b'T',
|
||||
HouseSystem::Meridian => b'X',
|
||||
HouseSystem::Vehlow => b'V',
|
||||
}
|
||||
}
|
||||
|
||||
/// Applies the frame to the C library state and returns the matching flags.
|
||||
/// Must be called with the lock held.
|
||||
fn apply_frame(frame: &Frame) -> i32 {
|
||||
let mut flags = 0;
|
||||
if let Some(ayanamsa) = frame.sidereal {
|
||||
// SAFETY: plain value arguments.
|
||||
unsafe { sys::swe_set_sid_mode(sid_mode(ayanamsa), 0.0, 0.0) };
|
||||
flags |= sys::SEFLG_SIDEREAL;
|
||||
}
|
||||
if let Some(obs) = frame.topocentric {
|
||||
// SAFETY: plain value arguments.
|
||||
unsafe { sys::swe_set_topo(obs.longitude, obs.latitude, obs.elevation) };
|
||||
flags |= sys::SEFLG_TOPOCTR;
|
||||
}
|
||||
flags
|
||||
}
|
||||
|
||||
/// One `swe_calc_ut` call; returns the 6 result values and the returned flags.
|
||||
/// Must be called with the lock held.
|
||||
fn calc(jd_ut: f64, ipl: i32, flags: i32) -> Result<([f64; 6], i32)> {
|
||||
let mut xx = [0.0f64; 6];
|
||||
let mut serr = [0 as c_char; sys::AS_MAXCH];
|
||||
// SAFETY: xx has the 6 elements and serr the AS_MAXCH bytes the API requires.
|
||||
let ret = unsafe { sys::swe_calc_ut(jd_ut, ipl, flags, xx.as_mut_ptr(), serr.as_mut_ptr()) };
|
||||
if ret == sys::ERR {
|
||||
return Err(EngineError::Calculation(c_string(&serr)));
|
||||
}
|
||||
Ok((xx, ret))
|
||||
}
|
||||
|
||||
impl Ephemeris for SwissEphemeris {
|
||||
fn info(&self) -> EphemerisInfo {
|
||||
EphemerisInfo {
|
||||
name: "Swiss Ephemeris".into(),
|
||||
version: self.version.clone(),
|
||||
precise_years: self.precise_years,
|
||||
license: "AGPL-3.0 (or Swiss Ephemeris Professional License)".into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn delta_t(&self, jd_ut: f64) -> f64 {
|
||||
let _guard = lock();
|
||||
let mut serr = [0 as c_char; sys::AS_MAXCH];
|
||||
// SAFETY: serr has AS_MAXCH bytes.
|
||||
unsafe { sys::swe_deltat_ex(jd_ut, sys::SEFLG_SWIEPH, serr.as_mut_ptr()) }
|
||||
}
|
||||
|
||||
fn sidereal_time(&self, jd_ut: f64) -> f64 {
|
||||
let _guard = lock();
|
||||
// SAFETY: plain value argument.
|
||||
unsafe { sys::swe_sidtime(jd_ut) }
|
||||
}
|
||||
|
||||
fn obliquity(&self, jd_ut: f64) -> Result<Obliquity> {
|
||||
let _guard = lock();
|
||||
let (xx, _) = calc(jd_ut, sys::SE_ECL_NUT, sys::SEFLG_SWIEPH)?;
|
||||
Ok(Obliquity {
|
||||
true_obliquity: xx[0],
|
||||
mean_obliquity: xx[1],
|
||||
nutation_longitude: xx[2],
|
||||
nutation_obliquity: xx[3],
|
||||
})
|
||||
}
|
||||
|
||||
fn position(&self, body: Body, jd_ut: f64, frame: &Frame) -> Result<BodyState> {
|
||||
let _guard = lock();
|
||||
let frame_flags = apply_frame(frame);
|
||||
let base = sys::SEFLG_SWIEPH | sys::SEFLG_SPEED;
|
||||
let ipl = body_id(body);
|
||||
|
||||
let (ecl, ret) = calc(jd_ut, ipl, base | frame_flags)?;
|
||||
// Equatorial coordinates are independent of the zodiac (no sidereal flag).
|
||||
let topo = frame_flags & sys::SEFLG_TOPOCTR;
|
||||
let (equ, _) = calc(jd_ut, ipl, base | topo | sys::SEFLG_EQUATORIAL)?;
|
||||
|
||||
Ok(BodyState {
|
||||
longitude: normalize(ecl[0]),
|
||||
latitude: ecl[1],
|
||||
distance: ecl[2],
|
||||
speed_longitude: ecl[3],
|
||||
speed_latitude: ecl[4],
|
||||
speed_distance: ecl[5],
|
||||
right_ascension: normalize(equ[0]),
|
||||
declination: equ[1],
|
||||
// The library silently switches to the Moshier ephemeris when no data
|
||||
// file covers the date.
|
||||
degraded_precision: ret & sys::SEFLG_MOSEPH != 0,
|
||||
})
|
||||
}
|
||||
|
||||
fn houses(&self, jd_ut: f64, observer: &GeoPosition, system: HouseSystem, frame: &Frame) -> Result<HouseResult> {
|
||||
let _guard = lock();
|
||||
// Houses are always geocentric; only the zodiac matters here.
|
||||
let flags = apply_frame(&Frame { sidereal: frame.sidereal, topocentric: None });
|
||||
// 37 slots: large enough even for the Gauquelin sectors.
|
||||
let mut cusps = [0.0f64; 37];
|
||||
let mut ascmc = [0.0f64; 10];
|
||||
let mut cusp_speed = [0.0f64; 37];
|
||||
let mut ascmc_speed = [0.0f64; 10];
|
||||
let mut serr = [0 as c_char; sys::AS_MAXCH];
|
||||
// SAFETY: all buffers are at least as large as the API requires.
|
||||
let ret = unsafe {
|
||||
sys::swe_houses_ex2(
|
||||
jd_ut,
|
||||
flags,
|
||||
observer.latitude,
|
||||
observer.longitude,
|
||||
house_code(system) as i32,
|
||||
cusps.as_mut_ptr(),
|
||||
ascmc.as_mut_ptr(),
|
||||
cusp_speed.as_mut_ptr(),
|
||||
ascmc_speed.as_mut_ptr(),
|
||||
serr.as_mut_ptr(),
|
||||
)
|
||||
};
|
||||
// On failure (quadrant systems inside the polar circles) the library
|
||||
// returns ERR and fills the cusps with Porphyry houses.
|
||||
let (used, fallback_reason) = if ret == sys::ERR {
|
||||
let msg = c_string(&serr);
|
||||
let reason = if msg.is_empty() {
|
||||
format!("{system:?} houses are undefined at latitude {:.2}°", observer.latitude)
|
||||
} else {
|
||||
msg
|
||||
};
|
||||
(HouseSystem::Porphyry, Some(reason))
|
||||
} else {
|
||||
(system, None)
|
||||
};
|
||||
|
||||
let mut out = [0.0f64; 12];
|
||||
for (i, c) in out.iter_mut().enumerate() {
|
||||
*c = normalize(cusps[i + 1]);
|
||||
}
|
||||
Ok(HouseResult {
|
||||
requested: system,
|
||||
used,
|
||||
fallback_reason,
|
||||
cusps: out,
|
||||
ascendant: normalize(ascmc[0]),
|
||||
midheaven: normalize(ascmc[1]),
|
||||
armc: normalize(ascmc[2]),
|
||||
vertex: normalize(ascmc[3]),
|
||||
equatorial_ascendant: normalize(ascmc[4]),
|
||||
co_ascendant_koch: normalize(ascmc[5]),
|
||||
co_ascendant_munkasey: normalize(ascmc[6]),
|
||||
polar_ascendant: normalize(ascmc[7]),
|
||||
ascendant_speed: ascmc_speed[0],
|
||||
midheaven_speed: ascmc_speed[1],
|
||||
vertex_speed: ascmc_speed[3],
|
||||
})
|
||||
}
|
||||
|
||||
fn illumination(&self, body: Body, jd_ut: f64) -> Result<f64> {
|
||||
let _guard = lock();
|
||||
let mut attr = [0.0f64; 20];
|
||||
let mut serr = [0 as c_char; sys::AS_MAXCH];
|
||||
// SAFETY: attr has the 20 elements the API requires.
|
||||
let ret =
|
||||
unsafe { sys::swe_pheno_ut(jd_ut, body_id(body), sys::SEFLG_SWIEPH, attr.as_mut_ptr(), serr.as_mut_ptr()) };
|
||||
if ret == sys::ERR {
|
||||
return Err(EngineError::Calculation(c_string(&serr)));
|
||||
}
|
||||
Ok(attr[1])
|
||||
}
|
||||
|
||||
fn ayanamsa(&self, jd_ut: f64, ayanamsa: Ayanamsa) -> Result<f64> {
|
||||
let _guard = lock();
|
||||
let mut daya = 0.0f64;
|
||||
let mut serr = [0 as c_char; sys::AS_MAXCH];
|
||||
// SAFETY: plain values and buffers of the required size.
|
||||
let ret = unsafe {
|
||||
sys::swe_set_sid_mode(sid_mode(ayanamsa), 0.0, 0.0);
|
||||
sys::swe_get_ayanamsa_ex_ut(jd_ut, sys::SEFLG_SWIEPH, &mut daya, serr.as_mut_ptr())
|
||||
};
|
||||
if ret == sys::ERR {
|
||||
return Err(EngineError::Calculation(c_string(&serr)));
|
||||
}
|
||||
Ok(daya)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn coverage_from_file_names() {
|
||||
let dir = std::env::temp_dir().join(format!("swe-cov-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
for f in ["sepl_18.se1", "sepl_12.se1", "semo_18.se1"] {
|
||||
std::fs::write(dir.join(f), b"").unwrap();
|
||||
}
|
||||
assert_eq!(planet_file_coverage(&dir), Some((1200, 2399)));
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user