Getting Started with Swiss Ephemeris in Python for Astrological Calculations

The Swiss Ephemeris (swisseph) library is a powerful tool for high-precision astronomical and astrological calculations. Here are some reasons why you might want to use it:

1. High Precision: Swiss Ephemeris is based on the DE431 ephemeris from NASA’s Jet Propulsion Laboratory (JPL), which is one of the most accurate ephemerides available. This makes it suitable for applications that require high precision, such as astrology, astronomy, and celestial navigation.
2. Wide Time Range: Swiss Ephemeris covers a wide time range, from 13201 BCE to 17191 CE. This makes it useful for historical research, as well as for predicting future celestial events.
3. Comprehensive Features: Swiss Ephemeris provides a wide range of features, including the calculation of planetary positions, houses, aspects, transits, solar and lunar returns, and more. It also provides functions for calculating sunrise and sunset times, as well as other astronomical phenomena.
4. Ease of Use: Swiss Ephemeris provides a simple and intuitive API, making it easy to use in your applications. It also provides bindings for several programming languages, including Python, which makes it accessible to a wide range of developers.
5. Open Source: Swiss Ephemeris is open source, which means you can use it for free in your applications, and you can also contribute to its development if you wish.Installation 

Swisseph can be installed in Python using pip, which is a package manager for Python. You can install it by running the following command in your terminal:

pip install pyswisseph

Make sure that you have pip installed and that Python is in your system’s path. 

Basic Usage 

Once you have installed swisseph, you can import it in your Python script as follows:

import swisseph as swe

Before making any calculations, it’s important to set the Ayanamsha. For Vedic astrology, N.C. Lahiri is commonly used:

swe.set_sid_mode(swe.SIDM_LAHIRI)

You can calculate the position of a planet using the calc_ut function. For example, to calculate the position of the Sun:

jd = swe.julday(2024, 3, 21)
xx, ret = swe.calc_ut(jd, swe.SUN)

The calc_ut function returns two values: xx and ret. xx is a list that contains the longitude, latitude, distance, and speed of the planet. ret is a flag that indicates whether the calculation was successful. 

Advanced Usage 

Swisseph can also calculate the Ascendant (Lagna), Rasi (Zodiac sign), planetary positions, houses of each planet, sunrise and sunset times, Tithi (Lunar day), and Vara (Day of the week) for a specified date, time, and location. This can serve as the foundation for a more complex astrological software. Here’s an example script that demonstrates these calculations:

import swisseph as swe
import json
from datetime import datetime

# Set the path to the Swiss Ephemeris data files
swe.set_ephe_path('ephe')

# Set the Ayanamsha to N.C. Lahiri
swe.set_sid_mode(swe.SIDM_LAHIRI)

# Get user input
name = input("Enter name: ")
dob = input("Enter date of birth (YYYY-MM-DD): ")
tob = input("Enter time of birth (HH:MM:SS): ")
place_of_birth = input("Enter place of birth: ")
latitude = float(input("Enter latitude: "))
longitude = float(input("Enter longitude: "))

# Parse the date and time of birth
year, month, day = map(int, dob.split('-'))
hour, minute, second = map(int, tob.split(':'))

# Calculate Julian Day
jd = swe.julday(year, month, day, hour + minute/60 + second/3600)

# Calculate the Ascendant using Equal house system
asc = swe.houses(jd, latitude, longitude, b'E')[0][0]

# Calculate the Rasi (Zodiac sign)
rasi = int((asc % 360) / 30)

# Calculate planetary positions and houses
planets = ['Sun', 'Moon', 'Mercury', 'Venus', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto']
planet_positions = {}
planet_houses = {}
for i, planet in enumerate(planets):
    xx, ret = swe.calc_ut(jd, i, swe.FLG_SPEED)  # Include velocities in the output
    planet_positions[planet] = xx[0]  # Longitude of the planet
    planet_houses[planet] = swe.house_pos(asc, latitude, 'E', xx[0], xx[1])  # House of the planet

# Calculate sunrise and sunset
next_sunrise = swe.rise_trans(jd, swe.SUN, geopos=(longitude, latitude, 0), rsmi=swe.CALC_RISE)[1][0]
next_sunset = swe.rise_trans(jd, swe.SUN, geopos=(longitude, latitude, 0), rsmi=swe.CALC_SET)[1][0]

# Convert sunrise and sunset times to date-time format
next_sunrise = datetime.fromtimestamp(swe.revjul(next_sunrise)).strftime('%Y-%m-%d %H:%M:%S')
next_sunset = datetime.fromtimestamp(swe.revjul(next_sunset)).strftime('%Y-%m-%d %H:%M:%S')

# Calculate Tithi (Lunar day)
moon_long = swe.calc_ut(jd, swe.MOON)[0][0]
sun_long = swe.calc_ut(jd, swe.SUN)[0][0]
tithi = int((moon_long - sun_long) % 360 / 12) + 1

# Calculate Vara (Day of the week)
vara = int((jd + 1) % 7)
vara_names = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

# Create a dictionary to store the results
data = {
    "name": name,
    "date_of_birth": dob,
    "time_of_birth": tob,
    "place_of_birth": place_of_birth,
    "latitude": latitude,
    "longitude": longitude,
    "ascendant": asc,
    "rasi": rasi,
    "planet_positions": planet_positions,
    "planet_houses": planet_houses,
    "next_sunrise": next_sunrise,
    "next_sunset": next_sunset,
    "tithi": tithi,
    "vara": vara_names[vara]
}

# Convert the dictionary to a JSON string
json_data = json.dumps(data, indent=4)

# Print the JSON string
print(json_data)

This script demonstrates how to use swisseph to perform a variety of astrological calculations. It serves as a good starting point for developing more complex astrological software. 

NOTE 

The swe.set_ephe_path('ephe') function is used to set the path to the directory containing the Swiss Ephemeris data files. These data files are necessary for the Swiss Ephemeris library to perform astronomical calculations. 

The argument 'ephe' is the path to the directory containing the data files. This can be an absolute path or a relative path. In this case, 'ephe' is a relative path, which means that the ephe directory is located in the same directory as the Python script. Here’s an example of how to use this function:

import swisseph as swe

# Set the path to the Swiss Ephemeris data files
swe.set_ephe_path('ephe')

# Now you can use other functions from the Swiss Ephemeris library
jd = swe.julday(2024, 3, 21)
xx, ret = swe.calc_ut(jd, swe.SUN)

print(f"The position of the Sun on March 21, 2024 is {xx[0]} degrees.")

In this example, the swe.set_ephe_path('ephe') function is called before any other Swiss Ephemeris functions. This ensures that the Swiss Ephemeris library knows where to find the data files it needs to perform calculations. 

Please note that you need to have the Swiss Ephemeris data files in the ephe directory for this to work. If the data files are not found, the Swiss Ephemeris library will not be able to perform calculations and will raise an error. You can download the Swiss Ephemeris data files from the Astrodienst website or GITHUB. Please note that this is a very basic calculation and may not be accurate for all purposes. For more accurate calculations, consider using a library specifically designed for Vedic astrology.