falakpy 0.1.0__tar.gz

falakpy-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: falakpy
+Version: 0.1.0
+Summary: Small Package Tool for Islamic Astronomy Related Computation and Visualization.
+Author-email: Muhamad Syazwan Faid <syazwaned90@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/msyazwanfaid/falakpy
+Project-URL: Issues, https://github.com/msyazwanfaid/falakpy/issues
+Keywords: Islamic Astronomy,qibla,prayer time,hijri calendar
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: skyfield

falakpy-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "falakpy"
+version = "0.1.0"
+description = "Small Package Tool for Islamic Astronomy Related Computation and Visualization."
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{ name = "Muhamad Syazwan Faid", email = "syazwaned90@gmail.com" }]
+keywords = ["Islamic Astronomy", "qibla", "prayer time", "hijri calendar"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Software Development :: Libraries",
+  "Typing :: Typed"
+]
+
+dependencies = ["skyfield"]  # keep it stdlib-only for the example
+
+[project.urls]
+Homepage = "https://github.com/msyazwanfaid/falakpy"
+Issues = "https://github.com/msyazwanfaid/falakpy/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

falakpy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

falakpy-0.1.0/src/falakpy/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+"""falakpy package initializer.
+
+Provides modules for:
+- qibla direction computation
+- prayer time calculation
+- lunar crescent observation
+"""
+
+from . import qibla, prayertime, lunar
+
+__all__ = ["qibla", "prayertime", "lunar"]

falakpy-0.1.0/src/falakpy/lunar.py

@@ -0,0 +1,126 @@
+def observedata(lat, lon, ele, tz, year, m, d, csv_filename="crescent_data.csv"):
+    from datetime import date, timedelta
+    import csv
+    from skyfield.api import load, wgs84
+    from skyfield import almanac
+    from skyfield.units import Angle
+    from skyfield.earthlib import refraction
+    from numpy import arccos
+
+    ts = load.timescale()
+    eph = load('de440s.bsp')
+    earth, sun, moon = eph['earth'], eph['sun'], eph['moon']
+
+    # Observer (works across Skyfield versions)
+    try:
+        location = wgs84.latlon(lat, lon, elevation_m=ele, center=earth)
+    except TypeError:
+        location = earth + wgs84.latlon(lat, lon, elevation_m=ele)
+
+    # Local-day window in UTC
+    t0 = ts.utc(year, m, d, 0 - tz, 0, 0)
+    t1 = ts.utc(year, m, d, 24 - tz, 0, 0)
+
+    # Apparent horizon for upper-limb sunset, with height & refraction
+    earth_radius_m = 6378136.6
+    side_over_hyp = earth_radius_m / (earth_radius_m + ele)
+    h_geom = Angle(radians=-arccos(side_over_hyp))           # dip from observer height
+    r = refraction(0.0, temperature_C=15.0, pressure_mbar=1013.25)
+    solar_radius_deg = 16/60
+    horizon_deg = -r + h_geom.degrees - solar_radius_deg
+
+    # Sunset within the local-day window
+    set_times_sun, _ = almanac.find_settings(location, sun, t0, t1, horizon_degrees=horizon_deg)
+    if len(set_times_sun) == 0:
+        raise RuntimeError("No sunset found in this local-day window.")
+    t_sunset = set_times_sun[0]
+    dt_sunset_local = t_sunset.utc_datetime() + timedelta(hours=tz)
+    sunset_str = dt_sunset_local.strftime("%H:%M:%S")
+
+    # Moonset within the local-day window (may be missing)
+    set_times_moon, _ = almanac.find_settings(location, moon, t0, t1, horizon_degrees=horizon_deg)
+    if len(set_times_moon) == 0:
+        t_moonset = None
+        moonset_str = "—"
+        lag_str = "—"
+    else:
+        t_moonset = set_times_moon[0]
+        dt_moonset_local = t_moonset.utc_datetime() + timedelta(hours=tz)
+        moonset_str = dt_moonset_local.strftime("%H:%M:%S")
+
+        # Lag = moonset - sunset (ensure positive same-evening)
+        lag_td = (t_moonset.utc_datetime() - t_sunset.utc_datetime())
+        if lag_td.total_seconds() < 0:
+            lag_td += timedelta(days=1)
+        hh = int(lag_td.total_seconds() // 3600)
+        mm = int((lag_td.total_seconds() % 3600) // 60)
+        ss = int(lag_td.total_seconds() % 60)
+        lag_str = f"{hh:02d}:{mm:02d}:{ss:02d}"
+
+    # Alt/Az at actual sunset
+    alt_moon, az_moon, _ = location.at(t_sunset).observe(moon).apparent().altaz()
+    alt_sun,  az_sun,  _ = location.at(t_sunset).observe(sun).apparent().altaz()
+
+    moon_alt_deg = float(alt_moon.degrees)
+    daz_deg = abs(float(az_moon.degrees) - float(az_sun.degrees))
+    arcv_deg = abs(moon_alt_deg - float(alt_sun.degrees))    # Arc of Vision
+    arcl_deg = float(
+        location.at(t_sunset).observe(sun).apparent()
+        .separation_from(location.at(t_sunset).observe(moon).apparent()).degrees
+    )  # Arc of Light
+
+    # Moon age at sunset: (JD_sunset - JD_conjunction_before)*24
+    jd_sunset = t_sunset.tt
+    # Search ±5 days around date; pick last conjunction BEFORE sunset
+    t0c = ts.utc(year, m, d - 5)
+    t1c = ts.utc(year, m, d + 5)
+    oc_func = almanac.oppositions_conjunctions(eph, eph['Moon'])
+    times_oc, events_oc = almanac.find_discrete(t0c, t1c, oc_func)
+    jd_conj = None
+    for ti, ei in zip(times_oc, events_oc):
+        if ei == 1 and ti.tt <= jd_sunset:  # 1 = conjunction
+            jd_conj = ti.tt
+    moon_age_hours = (jd_sunset - jd_conj) * 24.0 if jd_conj is not None else float('nan')
+
+    # Build row
+    date_str = date(year, m, d).strftime("%Y-%m-%d")
+    header = ["Date", "Sunset", "Moonset", "Lag Time", "Moon Age", "Moon Alt", "DAZ", "ArcV", "ArcL"]
+    row = [
+        date_str,
+        sunset_str,
+        moonset_str,
+        lag_str,
+        f"{moon_age_hours:.2f}",
+        f"{moon_alt_deg:.2f}",
+        f"{daz_deg:.2f}",
+        f"{arcv_deg:.2f}",
+        f"{arcl_deg:.2f}",
+    ]
+
+    # Pretty print
+    print("\n+------------+----------+----------+----------+----------+----------+----------+----------+----------+")
+    print("|    Date    |  Sunset  |  Moonset | LagTime  | MoonAge  | MoonAlt  |   DAZ    |   ArcV   |   ArcL   |")
+    print("+------------+----------+----------+----------+----------+----------+----------+----------+----------+")
+    print(f"| {date_str} | {sunset_str:8} | {moonset_str:8} | {lag_str:8} | "
+          f"{moon_age_hours:8.2f} | {moon_alt_deg:8.2f} | {daz_deg:8.2f} | {arcv_deg:8.2f} | {arcl_deg:8.2f} |")
+    print("+------------+----------+----------+----------+----------+----------+----------+----------+----------+")
+
+    # Save CSV
+    with open(csv_filename, "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(header)
+        writer.writerow(row)
+
+    print(f"\n✅ Saved to CSV file: {csv_filename}")
+
+    return {
+        "Date": date_str,
+        "Sunset": sunset_str,
+        "Moonset": moonset_str,
+        "Lag Time": lag_str,
+        "Moon Age (h)": f"{moon_age_hours:.2f}",
+        "Moon Alt (deg)": f"{moon_alt_deg:.2f}",
+        "DAZ (deg)": f"{daz_deg:.2f}",
+        "ArcV (deg)": f"{arcv_deg:.2f}",
+        "ArcL (deg)": f"{arcl_deg:.2f}",
+    }

falakpy-0.1.0/src/falakpy/prayertime.py

@@ -0,0 +1,514 @@
+def subuh(lat,long,ele,tz,y,m,d):
+  from datetime import datetime, timedelta, date
+  from skyfield.api import load, wgs84
+  from skyfield import almanac
+  import numpy as np
+
+  # -------- Settings --------
+  lat_location = lat
+  long_location = long
+  ele = ele
+  timezone = tz                 # UTC+8 (Malaysia)
+  year = y
+  month = m
+  day = d
+
+  the_day = date(year, month, day)
+
+  target_alt_deg = -17.99       # e.g., astronomical twilight
+  tolerance_alt = 0.01          # ± degrees around target altitude
+
+
+  # -------- Skyfield setup --------
+  ts = load.timescale()
+  eph = load('de440s.bsp')
+  earth, sun = eph['earth'], eph['sun']
+  location = earth + wgs84.latlon(lat_location, long_location, elevation_m=ele)
+
+  def make_altitude_predicate(target_alt_deg: float, tolerance_alt: float):
+    """True when Sun altitude is within [target - tol, target + tol]."""
+    lo = target_alt_deg - tolerance_alt
+    hi = target_alt_deg + tolerance_alt
+
+    def in_alt_band(t):
+        alt, az, _ = location.at(t).observe(sun).apparent().altaz()
+        return (alt.degrees >= lo) & (alt.degrees <= hi)
+
+    # hints for Skyfield’s search
+    in_alt_band.step_days = 0.00001     
+    in_alt_band.rough_period = 0.5    # ≈12 h between crossings
+    return in_alt_band
+
+  pred = make_altitude_predicate(target_alt_deg, tolerance_alt)
+
+  def local_from_utc(dt_utc):
+    return dt_utc + timedelta(hours=timezone)
+
+  def sun_altitude_intervals_for_day(d: date):
+    """Return [(entry_time_utc, exit_time_utc)] for one local day where altitude is in band."""
+    t0 = ts.utc(year, month, day, 0 - timezone, 0, 0)
+    t1 = ts.utc(year, month, day, 12 - timezone, 0, 0)
+
+    times, states = almanac.find_discrete(t0, t1, pred)
+    intervals = []
+
+    # if we start inside True state, prepend opening time
+    is_true_at_start = bool(pred(t0)) if np.isscalar(pred(t0)) else bool(pred(t0).any())
+    if is_true_at_start:
+        times = ts.tt_jd(np.insert(times.tt, 0, t0.tt))
+        states = np.insert(states, 0, True)
+
+    # build [entry, exit) pairs for True segments
+    for i in range(len(times) - 1):
+        if states[i]:
+            intervals.append((times[i], times[i + 1]))
+
+    # if last state continues to t1
+    if len(times) > 0 and states[-1]:
+        intervals.append((times[-1], t1))
+
+    return intervals
+
+  # -------- Run for one day --------
+  intervals = sun_altitude_intervals_for_day(the_day)
+
+  #print(f"Sun altitude windows for {the_day.isoformat()} (local UTC{timezone:+d}), "
+  #    f"alt ≈ {target_alt_deg}° ±{tolerance_alt}°")
+
+  if not intervals:
+    print("  — none —")
+  else:
+    for idx, (entry, exit_) in enumerate(intervals, start=1):
+        utc_entry = entry.utc_datetime()
+        utc_exit  = exit_.utc_datetime()
+        loc_entry = local_from_utc(utc_entry)
+        loc_exit  = local_from_utc(utc_exit)
+        duration_min = (utc_exit - utc_entry).total_seconds() / 60.0
+
+        # optional: altitude & azimuth at entry
+        alt_e, az_e, _ = location.at(entry).observe(sun).apparent().altaz()
+
+  #      print(f"  #{idx}: {loc_entry.strftime('%H:%M:%S')} → {loc_exit.strftime('%H:%M:%S')}"
+   #           f"  | duration: {duration_min:.2f} min"
+   #           f"  | alt_entry: {alt_e.degrees:.2f}°  az: {az_e.degrees:.2f}°")
+        z=loc_entry.strftime('%H:%M:%S')
+  return z
+
+def syuruk(lat,long,ele,tz,y,m,d):
+  from datetime import datetime, timedelta, date
+  from skyfield.api import load, wgs84
+  from skyfield import almanac
+  import numpy as np
+
+  # -------- Settings --------
+  lat_location = lat
+  long_location = long
+  ele = ele
+  timezone = tz                 # UTC+8 (Malaysia)
+  year = y
+  month = m
+  day = d
+
+  ts = load.timescale()
+  eph = load('de440s.bsp')
+  planets = load('de440s.bsp')
+  earth = planets['earth']
+  sun = planets['sun']
+  location = earth + wgs84.latlon(lat_location, long_location, elevation_m=ele)
+
+  t0 = ts.utc(year, month, day-1)
+  t1 = ts.utc(year, month, day)
+
+  from skyfield.units import Angle
+  from numpy import arccos
+  from skyfield.earthlib import refraction
+
+  altitude_m = ele
+  earth_radius_m = 6378136.6
+  side_over_hypotenuse = earth_radius_m / (earth_radius_m + altitude_m)
+  h = Angle(radians=-arccos(side_over_hypotenuse))
+  solar_radius_degrees = 16 / 60
+  r = refraction(0.0, temperature_C=15.0, pressure_mbar=1030.0)
+
+  t, y = almanac.find_risings(location, sun, t0, t1, horizon_degrees=-r + h.degrees - solar_radius_degrees)
+  h, m, s = t.utc.hour, t.utc.minute, t.utc.second
+  syuruk_time = float(np.array(h).item() + np.array(m).item()/60 + np.array(s).item()/3600 + timezone)
+  syuruk_time %= 24  # Ensure 24-hour clock format
+
+  syuruk_time = float(syuruk_time)
+  degrees = int(syuruk_time)
+  decimal_part = syuruk_time  - degrees
+  minutes_total = decimal_part * 60
+  minutes = int(minutes_total)
+  seconds = round((minutes_total - minutes) * 60)
+  sun_astro = location.at(ts.utc(year, month, day, h, m, s)).observe(sun)
+  sun_alt, _, _ = sun_astro.apparent().altaz()
+  sun_alt, _, _ = sun_astro.apparent().altaz()
+  if sun_alt.degrees >= 0:
+      syuruk = "Syuruk Does Not Occur"
+  else:
+      syuruk = f"{degrees}:{minutes}:{seconds}"
+
+  return syuruk
+
+def zuhur(lat,long,ele,tz,y,m,d):
+  from datetime import datetime, timedelta, date
+  from skyfield.api import load, wgs84
+  from skyfield import almanac
+  import numpy as np
+
+  # -------- Settings --------
+  lat_location = lat
+  long_location = long
+  ele = ele
+  timezone = tz                 # UTC+8 (Malaysia)
+  year = y
+  month = m
+  day = d
+
+  ts = load.timescale()
+  eph = load('de440s.bsp')
+  planets = load('de440s.bsp')
+  earth = planets['earth']
+  sun = planets['sun']
+  location = earth + wgs84.latlon(lat_location, long_location, elevation_m=ele)
+
+  t0 = ts.utc(year, month, day-1)
+  t1 = ts.utc(year, month, day)
+
+  from skyfield.units import Angle
+  from numpy import arccos
+  from skyfield.earthlib import refraction
+
+  t = almanac.find_transits(location, sun, t0, t1)
+  h = t.utc.hour
+  m = t.utc.minute
+  s = t.utc.second
+
+  #print(hour_solar_transit)
+  #print(minutes_solar_transit )
+  #print(second_solar_transit)
+  #zuhur_time = hour_solar_transit + (minutes_solar_transit / 60) + (second_solar_transit / 3600 ) + timezone + 0.017778
+  zuhur_time = float(np.array(h).item() + np.array(m).item()/60 + np.array(s).item()/3600 + timezone+ 0.017778)
+
+
+  zuhur_time = float(zuhur_time)
+  degrees = int(zuhur_time )
+  decimal_part = zuhur_time  - degrees
+  minutes_total = decimal_part * 60
+  minutes = int(minutes_total)
+
+  seconds = round((minutes_total - minutes) * 60)
+  #print(f"{degrees}° {minutes}′ {seconds}″")
+
+  sun_astro = location.at(ts.utc(year, month, day, h, m, s)).observe(sun)
+  sun_alt, _, _ = sun_astro.apparent().altaz()
+  alt_deg = float(np.atleast_1d(sun_alt.degrees)[0])   # <- force scalar
+
+  # Check if the sun is above the horizon at zuhur time
+  if sun_alt.degrees <= 0:
+      zuhur = "Zuhur Does Not Occur"
+  else:
+      zuhur = f"{degrees}:{minutes}:{seconds}"
+  altitude_zuhur = alt_deg
+
+  return zuhur,altitude_zuhur
+
+def asar(lat,long,ele,tz,y,m,d):
+  from datetime import datetime, timedelta, date
+  from skyfield.api import load, wgs84
+  from skyfield import almanac
+  import numpy as np
+  import math
+
+  # -------- Settings --------
+  lat_location = lat
+  long_location = long
+  ele = ele
+  timezone = tz                 # UTC+8 (Malaysia)
+  year = y
+  month = m
+  day = d
+
+  the_day = date(year, month, day)
+
+  _, altitude_zuhur = zuhur(lat,long,ele,tz,y,m,d)
+
+    # Noon shadow and Asar target altitude
+  s0 = 1.0 / math.tan(math.radians(altitude_zuhur))
+  h_asar = math.degrees(math.atan(1.0 / (1.0 + s0))) 
+
+  target_alt_deg = h_asar       # angle asar
+  tolerance_alt = 0.01          # ± degrees around target altitude
+
+
+  # -------- Skyfield setup --------
+  ts = load.timescale()
+  eph = load('de440s.bsp')
+  earth, sun = eph['earth'], eph['sun']
+  location = earth + wgs84.latlon(lat_location, long_location, elevation_m=ele)
+
+  def make_altitude_predicate(target_alt_deg: float, tolerance_alt: float):
+    """True when Sun altitude is within [target - tol, target + tol]."""
+    lo = target_alt_deg - tolerance_alt
+    hi = target_alt_deg + tolerance_alt
+
+    def in_alt_band(t):
+        alt, az, _ = location.at(t).observe(sun).apparent().altaz()
+        return (alt.degrees >= lo) & (alt.degrees <= hi)
+
+    # hints for Skyfield’s search
+    in_alt_band.step_days = 0.00001     
+    in_alt_band.rough_period = 0.5    # ≈12 h between crossings
+    return in_alt_band
+
+  pred = make_altitude_predicate(target_alt_deg, tolerance_alt)
+
+  def local_from_utc(dt_utc):
+    return dt_utc + timedelta(hours=timezone)
+
+  def sun_altitude_intervals_for_day(d: date):
+    """Return [(entry_time_utc, exit_time_utc)] for one local day where altitude is in band."""
+    t0 = ts.utc(year, month, day, 12 - timezone, 0, 0)
+    t1 = ts.utc(year, month, day, 24 - timezone, 0, 0)
+
+    times, states = almanac.find_discrete(t0, t1, pred)
+    intervals = []
+
+    # if we start inside True state, prepend opening time
+    is_true_at_start = bool(pred(t0)) if np.isscalar(pred(t0)) else bool(pred(t0).any())
+    if is_true_at_start:
+        times = ts.tt_jd(np.insert(times.tt, 0, t0.tt))
+        states = np.insert(states, 0, True)
+
+    # build [entry, exit) pairs for True segments
+    for i in range(len(times) - 1):
+        if states[i]:
+            intervals.append((times[i], times[i + 1]))
+
+    # if last state continues to t1
+    if len(times) > 0 and states[-1]:
+        intervals.append((times[-1], t1))
+
+    return intervals
+
+  # -------- Run for one day --------
+  intervals = sun_altitude_intervals_for_day(the_day)
+
+  #print(f"Sun altitude windows for {the_day.isoformat()} (local UTC{timezone:+d}), "
+  #    f"alt ≈ {target_alt_deg}° ±{tolerance_alt}°")
+
+  if not intervals:
+    print("  — none —")
+  else:
+    for idx, (entry, exit_) in enumerate(intervals, start=1):
+        utc_entry = entry.utc_datetime()
+        utc_exit  = exit_.utc_datetime()
+        loc_entry = local_from_utc(utc_entry)
+        loc_exit  = local_from_utc(utc_exit)
+        duration_min = (utc_exit - utc_entry).total_seconds() / 60.0
+
+        # optional: altitude & azimuth at entry
+        alt_e, az_e, _ = location.at(entry).observe(sun).apparent().altaz()
+
+   #     print(f"  #{idx}: {loc_entry.strftime('%H:%M:%S')} → {loc_exit.strftime('%H:%M:%S')}"
+   #           f"  | duration: {duration_min:.2f} min"
+   #           f"  | alt_entry: {alt_e.degrees:.2f}°  az: {az_e.degrees:.2f}°")
+        z=loc_entry.strftime('%H:%M:%S')
+  return z
+
+def maghrib(lat,long,ele,tz,y,m,d):
+  from datetime import datetime, timedelta, date
+  from skyfield.api import load, wgs84
+  from skyfield import almanac
+  import numpy as np
+
+  # -------- Settings --------
+  lat_location = lat
+  long_location = long
+  ele = ele
+  timezone = tz                 # UTC+8 (Malaysia)
+  year = y
+  month = m
+  day = d
+
+  ts = load.timescale()
+  eph = load('de440s.bsp')
+  planets = load('de440s.bsp')
+  earth = planets['earth']
+  sun = planets['sun']
+  location = earth + wgs84.latlon(lat_location, long_location, elevation_m=ele)
+
+  t0 = ts.utc(year, month, day-1)
+  t1 = ts.utc(year, month, day)
+
+  from skyfield.units import Angle
+  from numpy import arccos
+  from skyfield.earthlib import refraction
+
+  altitude_m = ele
+  earth_radius_m = 6378136.6
+  side_over_hypotenuse = earth_radius_m / (earth_radius_m + altitude_m)
+  h = Angle(radians=-arccos(side_over_hypotenuse))
+  solar_radius_degrees = 16 / 60
+  r = refraction(0.0, temperature_C=15.0, pressure_mbar=1030.0)
+
+  t, y = almanac.find_settings(location, sun, t0, t1, horizon_degrees=-r + h.degrees - solar_radius_degrees)
+  h, m, s = t.utc.hour, t.utc.minute, t.utc.second
+  maghrib_time = float(np.array(h).item() + np.array(m).item()/60 + np.array(s).item()/3600 + timezone)
+  maghrib_time %= 24  # Ensure 24-hour clock format
+
+  maghrib_time = float(maghrib_time)
+  degrees = int(maghrib_time)
+  decimal_part = maghrib_time  - degrees
+  minutes_total = decimal_part * 60
+  minutes = int(minutes_total)
+  seconds = round((minutes_total - minutes) * 60)
+  sun_astro = location.at(ts.utc(year, month, day, h, m, s)).observe(sun)
+  sun_alt, _, _ = sun_astro.apparent().altaz()
+  sun_alt, _, _ = sun_astro.apparent().altaz()
+  if sun_alt.degrees >= 0:
+      maghrib = "Maghrib Does Not Occur"
+  else:
+      maghrib = f"{degrees}:{minutes}:{seconds}"
+
+  return maghrib
+
+def isyak(lat,long,ele,tz,y,m,d):
+  from datetime import datetime, timedelta, date
+  from skyfield.api import load, wgs84
+  from skyfield import almanac
+  import numpy as np
+
+  # -------- Settings --------
+  lat_location = lat
+  long_location = long
+  ele = ele
+  timezone = tz                 # UTC+8 (Malaysia)
+  year = y
+  month = m
+  day = d
+
+  the_day = date(year, month, day)
+
+  target_alt_deg = -17.99       # e.g., astronomical twilight
+  tolerance_alt = 0.01          # ± degrees around target altitude
+
+
+  # -------- Skyfield setup --------
+  ts = load.timescale()
+  eph = load('de440s.bsp')
+  earth, sun = eph['earth'], eph['sun']
+  location = earth + wgs84.latlon(lat_location, long_location, elevation_m=ele)
+
+  def make_altitude_predicate(target_alt_deg: float, tolerance_alt: float):
+    """True when Sun altitude is within [target - tol, target + tol]."""
+    lo = target_alt_deg - tolerance_alt
+    hi = target_alt_deg + tolerance_alt
+
+    def in_alt_band(t):
+        alt, az, _ = location.at(t).observe(sun).apparent().altaz()
+        return (alt.degrees >= lo) & (alt.degrees <= hi)
+
+    # hints for Skyfield’s search
+    in_alt_band.step_days = 0.00001     
+    in_alt_band.rough_period = 0.5    # ≈12 h between crossings
+    return in_alt_band
+
+  pred = make_altitude_predicate(target_alt_deg, tolerance_alt)
+
+  def local_from_utc(dt_utc):
+    return dt_utc + timedelta(hours=timezone)
+
+  def sun_altitude_intervals_for_day(d: date):
+    """Return [(entry_time_utc, exit_time_utc)] for one local day where altitude is in band."""
+    t0 = ts.utc(year, month, day, 12 - timezone, 0, 0)
+    t1 = ts.utc(year, month, day, 24 - timezone, 0, 0)
+
+    times, states = almanac.find_discrete(t0, t1, pred)
+    intervals = []
+
+    # if we start inside True state, prepend opening time
+    is_true_at_start = bool(pred(t0)) if np.isscalar(pred(t0)) else bool(pred(t0).any())
+    if is_true_at_start:
+        times = ts.tt_jd(np.insert(times.tt, 0, t0.tt))
+        states = np.insert(states, 0, True)
+
+    # build [entry, exit) pairs for True segments
+    for i in range(len(times) - 1):
+        if states[i]:
+            intervals.append((times[i], times[i + 1]))
+
+    # if last state continues to t1
+    if len(times) > 0 and states[-1]:
+        intervals.append((times[-1], t1))
+
+    return intervals
+
+  # -------- Run for one day --------
+  intervals = sun_altitude_intervals_for_day(the_day)
+
+ # print(f"Sun altitude windows for {the_day.isoformat()} (local UTC{timezone:+d}), "
+  #    f"alt ≈ {target_alt_deg}° ±{tolerance_alt}°")
+
+  if not intervals:
+    print("  — none —")
+  else:
+    for idx, (entry, exit_) in enumerate(intervals, start=1):
+        utc_entry = entry.utc_datetime()
+        utc_exit  = exit_.utc_datetime()
+        loc_entry = local_from_utc(utc_entry)
+        loc_exit  = local_from_utc(utc_exit)
+        duration_min = (utc_exit - utc_entry).total_seconds() / 60.0
+
+        # optional: altitude & azimuth at entry
+        alt_e, az_e, _ = location.at(entry).observe(sun).apparent().altaz()
+
+   #     print(f"  #{idx}: {loc_entry.strftime('%H:%M:%S')} → {loc_exit.strftime('%H:%M:%S')}"
+   #           f"  | duration: {duration_min:.2f} min"
+   #           f"  | alt_entry: {alt_e.degrees:.2f}°  az: {az_e.degrees:.2f}°")
+        z=loc_entry.strftime('%H:%M:%S')
+  return z
+
+
+
+def singleday(lat, lon, ele, tz, y, m, d, csv_filename="prayer_times.csv"):
+
+    import csv
+    from datetime import date
+    """
+    Generate prayer times for one date, print as table, and also save as CSV.
+    """
+    # --- get each prayer time ---
+    subuh_time    = subuh(lat, lon, ele, tz, y, m, d)
+    syuruk_time   = syuruk(lat, lon, ele, tz, y, m, d)
+    zuhur_time, _ = zuhur(lat, lon, ele, tz, y, m, d)
+    asar_time     = asar(lat, lon, ele, tz, y, m, d)
+    maghrib_time  = maghrib(lat, lon, ele, tz, y, m, d)
+    isyak_time    = isyak(lat, lon, ele, tz, y, m, d)
+
+    # --- Prepare data row ---
+    date_str = date(y, m, d).strftime("%Y-%m-%d")
+    header = ["Date", "Subuh", "Syuruk", "Zuhur", "Asar", "Maghrib", "Isyak"]
+    row = [date_str, subuh_time, syuruk_time, zuhur_time, asar_time, maghrib_time, isyak_time]
+
+    # --- Print table to screen ---
+    print("\n+------------+----------+----------+----------+----------+----------+----------+")
+    print("|    Date    |  Subuh   |  Syuruk  |  Zuhur   |   Asar   | Maghrib  |  Isyak   |")
+    print("+------------+----------+----------+----------+----------+----------+----------+")
+    print(f"| {date_str} | {subuh_time:8} | {syuruk_time:8} | {zuhur_time:8} | "
+          f"{asar_time:8} | {maghrib_time:8} | {isyak_time:8} |")
+    print("+------------+----------+----------+----------+----------+----------+----------+")
+
+    # --- Write to CSV file ---
+    with open(csv_filename, mode="w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(header)
+        writer.writerow(row)
+
+    print(f"\n✅ Saved to CSV file: {csv_filename}")
+
+
+
+
+

falakpy-0.1.0/src/falakpy/qibla.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""qibla
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1UK-U7P-Ab71HAPQJe0c4NNwdZ0TKaGxG
+"""
+
+import math
+
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class QiblaDirection:
+    decimal: float  # decimal degrees, 0..360
+    degree: str
+
+def direction (lat : float, long: float) -> QiblaDirection:
+
+
+  φ_Location = lat
+  λ_Location = long
+  φ_Kaabah = 21.4225
+  λ_Kaabah = 39.8262
+  Difference_Longitude   = abs(λ_Location-λ_Kaabah )
+
+
+  #Calculation of Qibla Direction
+  import math
+
+  A = math.sin(math.radians(abs(Difference_Longitude)))
+  B = math.cos(math.radians(φ_Location))*math.tan(math.radians(φ_Kaabah))
+  C = math.sin(math.radians(φ_Location))  * math.cos(math.radians(Difference_Longitude))
+  D = A/(B-C)
+  θ     = math.degrees(math.atan(D))
+
+  #Determine the Azimuth of the Qibla
+  if Difference_Longitude > 180:
+      delta_λ = 360 - Difference_Longitude
+  else:
+      delta_λ = Difference_Longitude
+
+  if θ > 0:
+      if λ_Location > λ_Kaabah:
+          quadrant = "UB"  # Utara Barat
+      elif λ_Location <= λ_Kaabah:
+          quadrant = "UT"  # Utara Timur
+      elif λ_Location < 0:
+          if c >= 180:
+              quadrant = "UB"
+          else:
+              quadrant = "UT"
+  elif θ < 0:
+      if λ_Location > λ_Kaabah:
+          quadrant = "SB"  # Selatan Barat
+      elif λ_Location <= λ_Kaabah:
+          quadrant = "ST"  # Selatan Timur
+      elif λ_Location < 0:
+          if c >= 180:
+              quadrant = "SB"
+          else:
+              quadrant = "ST"
+
+  if quadrant == "UB":
+      azimuth_kiblat = 360 - θ
+  elif quadrant == "SB":
+      azimuth_kiblat = 180 - θ
+  elif quadrant == "UT":
+      azimuth_kiblat = θ
+  elif quadrant == "ST":
+      azimuth_kiblat = 180 + θ
+
+  # To Convert in Degree Form
+
+  degrees = int(azimuth_kiblat)
+  decimal_part = azimuth_kiblat - degrees
+  minutes_total = decimal_part = 60
+  minutes = int(minutes_total)
+  seconds = round((minutes_total - minutes) * 60)
+  #print(f'The azimuth of the Qibla for Location with coordinate {φ_Location} Latitude, {λ_Location} Longitude, is {degrees}° {minutes}′ {seconds}″')
+  outputdegree = f"{degrees}° {minutes}′ {seconds}″"
+
+  return QiblaDirection(decimal=azimuth_kiblat, degree=outputdegree)
+
+
+
+

falakpy-0.1.0/src/falakpy.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: falakpy
+Version: 0.1.0
+Summary: Small Package Tool for Islamic Astronomy Related Computation and Visualization.
+Author-email: Muhamad Syazwan Faid <syazwaned90@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/msyazwanfaid/falakpy
+Project-URL: Issues, https://github.com/msyazwanfaid/falakpy/issues
+Keywords: Islamic Astronomy,qibla,prayer time,hijri calendar
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: skyfield

falakpy-0.1.0/src/falakpy.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+src/falakpy/__init__.py
+src/falakpy/lunar.py
+src/falakpy/prayertime.py
+src/falakpy/qibla.py
+src/falakpy.egg-info/PKG-INFO
+src/falakpy.egg-info/SOURCES.txt
+src/falakpy.egg-info/dependency_links.txt
+src/falakpy.egg-info/requires.txt
+src/falakpy.egg-info/top_level.txt

falakpy-0.1.0/src/falakpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

falakpy-0.1.0/src/falakpy.egg-info/requires.txt

@@ -0,0 +1 @@
+skyfield

falakpy-0.1.0/src/falakpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+falakpy