Optional params appended None type.

theriftlab · theriftlab · commit 62882446e068 · 2025-04-27T11:00:39.000-07:00
diff --git a/immanuel/charts.py b/immanuel/charts.py
@@ -32,7 +32,7 @@
 class Subject:
     """ Simple class to model a chart subject - essentially just
     a time and place. """
-    def __init__(self, date_time: str | float | datetime, latitude: float | list | tuple | str, longitude: float | list | tuple | str, timezone_offset: float = None, time_is_dst: bool = None) -> None:
+    def __init__(self, date_time: str | float | datetime, latitude: float | list | tuple | str, longitude: float | list | tuple | str, timezone_offset: float | None = None, time_is_dst: bool | None = None) -> None:
         self.latitude, self.longitude = (convert.to_dec(v) for v in (latitude, longitude))
         self.time_is_dst = time_is_dst
         self.date_time = date.to_datetime(
@@ -159,7 +159,7 @@ def set_wrapped_weightings(self) -> None:
 class Natal(Chart):
     """ Standard natal chart generates data straight from the passed
     native information. """
-    def __init__(self, native: Subject, aspects_to: Chart = None) -> None:
+    def __init__(self, native: Subject, aspects_to: Chart | None = None) -> None:
         self._native = native
         super().__init__(chart.NATAL, aspects_to)
 
@@ -196,7 +196,7 @@ def generate(self) -> None:
 
 class SolarReturn(Chart):
     """ Solar return chart for the given year. """
-    def __init__(self, native: Subject, year: int, aspects_to: Chart = None) -> None:
+    def __init__(self, native: Subject, year: int, aspects_to: Chart | None = None) -> None:
         self._native = native
         self._solar_return_year = year
         super().__init__(chart.SOLAR_RETURN, aspects_to)
@@ -254,7 +254,7 @@ def set_wrapped_solar_return_date_time(self) -> None:
 class Progressed(Chart):
     """ Secondary progression chart uses the MC progression method from
     settings. """
-    def __init__(self, native: Subject, date_time: datetime | str, aspects_to: Chart = None) -> None:
+    def __init__(self, native: Subject, date_time: datetime | str, aspects_to: Chart | None = None) -> None:
         self._native = native
         self._date_time = date_time
         super().__init__(chart.PROGRESSED, aspects_to)
@@ -334,7 +334,7 @@ def set_wrapped_progression_method(self) -> None:
 
 class Composite(Chart):
     """ Generates a midpoint chart based on the two passed sets of data. """
-    def __init__(self, native: Subject, partner: Subject, aspects_to: Chart = None) -> None:
+    def __init__(self, native: Subject, partner: Subject, aspects_to: Chart | None = None) -> None:
         self._native = native
         self._partner = partner
         super().__init__(chart.COMPOSITE, aspects_to)
@@ -450,7 +450,7 @@ def set_wrapped_partner(self):
 class Transits(Chart):
     """ Chart of the moment for the given coordinates. Structurally identical
     to the natal chart. Coordinates default to those specified in settings. """
-    def __init__(self, latitude: float | list | tuple | str = settings.default_latitude, longitude: float | list | tuple | str = settings.default_longitude, aspects_to: Chart = None, houses_for_aspected: bool = False) -> None:
+    def __init__(self, latitude: float | list | tuple | str = settings.default_latitude, longitude: float | list | tuple | str = settings.default_longitude, aspects_to: Chart | None = None, houses_for_aspected: bool = False) -> None:
         lat, lon = (convert.to_dec(v) for v in (latitude, longitude))
         timezone = date.timezone_name(lat, lon)
         date_time = datetime.now(tz=ZoneInfo(timezone))
diff --git a/immanuel/classes/localize.py b/immanuel/classes/localize.py
@@ -51,7 +51,7 @@ def reset() -> None:
         MAPPINGS = {}
 
 
-def localize(input: str, context: str = None) -> str:
+def localize(input: str, context: str | None = None) -> str:
     if Localize.translation is None:
         return input
 
diff --git a/immanuel/classes/wrap.py b/immanuel/classes/wrap.py
@@ -94,7 +94,7 @@ def __str__(self) -> str:
 
 
 class DateTime:
-    def __init__(self, dt: datetime | float, armc: dict | float = None, latitude: float = None, longitude: float = None, time_is_dst: bool = None) -> None:
+    def __init__(self, dt: datetime | float, armc: dict | float = None, latitude: float | None = None, longitude: float | None = None, time_is_dst: bool | None = None) -> None:
         self.datetime = date.to_datetime(dt, latitude, longitude)
         self.timezone = self.datetime.tzname()
         self.ambiguous = date.ambiguous(self.datetime) and time_is_dst is None
@@ -186,11 +186,11 @@ class Object:
     def __init__(
         self,
         object: dict,
-        date_time: datetime = None,
-        house: int = None,
-        out_of_bounds: bool = None,
-        in_sect: bool = None,
-        dignity_state: dict = None,
+        date_time: datetime | None = None,
+        house: int | None = None,
+        out_of_bounds: bool | None = None,
+        in_sect: bool | None = None,
+        dignity_state: dict | None = None,
     ) -> None:
         self.index = object['index']
 
diff --git a/immanuel/tools/calculate.py b/immanuel/tools/calculate.py
@@ -128,7 +128,7 @@ def is_in_sect(object: dict, is_daytime: bool, sun: dict | float = None) -> bool
     return False
 
 
-def is_out_of_bounds(object: dict | float, jd: float = None, obliquity: float = None) -> bool:
+def is_out_of_bounds(object: dict | float, jd: float | None = None, obliquity: float | None = None) -> bool:
     """ Returns whether the passed object is out of bounds either on the passed
     Julian date or relative to the passed obliquity. """
     if isinstance(object, dict):
diff --git a/immanuel/tools/convert.py b/immanuel/tools/convert.py
@@ -40,7 +40,7 @@ def dec_to_dms(dec: float, round_to: tuple = ROUND_SECOND, pad_rounded: bool = F
     return dms + (0,) * (3-round_to[0]) if pad_rounded else dms
 
 
-def dms_to_string(dms: list | tuple, format: int = FORMAT_DMS, round_to: tuple = ROUND_SECOND, pad_rounded: bool = None) -> str:
+def dms_to_string(dms: list | tuple, format: int = FORMAT_DMS, round_to: tuple = ROUND_SECOND, pad_rounded: bool | None = None) -> str:
     """ Returns a D:M:S list as either a D:M:S, D°M'S" or
     lat/lon coordinate string. """
     pad_rounded = True if format in (FORMAT_LAT, FORMAT_LON) or (pad_rounded is None and format != FORMAT_DMS) else pad_rounded
@@ -66,7 +66,7 @@ def string_to_dms(string: str, round_to: tuple = ROUND_SECOND, pad_rounded: bool
     return dec_to_dms(string_to_dec(string), round_to, pad_rounded)
 
 
-def dec_to_string(dec: float, format: int = FORMAT_DMS, round_to: tuple = ROUND_SECOND, pad_rounded: bool = None) -> str:
+def dec_to_string(dec: float, format: int = FORMAT_DMS, round_to: tuple = ROUND_SECOND, pad_rounded: bool | None = None) -> str:
     """ Returns a decimal float as either a D:M:S or a D°M'S" string. """
     return dms_to_string(dec_to_dms(dec, round_to), format, round_to, pad_rounded)
 
@@ -108,7 +108,7 @@ def to_dms(value: float | list | tuple | str, round_to: tuple = ROUND_SECOND, pa
     return None
 
 
-def to_string(value: float | list | tuple | str, format: int = FORMAT_DMS, round_to: tuple = ROUND_SECOND, pad_rounded: bool = None) -> str:
+def to_string(value: float | list | tuple | str, format: int = FORMAT_DMS, round_to: tuple = ROUND_SECOND, pad_rounded: bool | None = None) -> str:
     """ If the input type is unknown, this will guess and convert. """
     if isinstance(value, float):
         return dec_to_string(value, format, round_to, pad_rounded)
diff --git a/immanuel/tools/date.py b/immanuel/tools/date.py
@@ -40,13 +40,13 @@ def get_timezone(lat: float, lon: float, offset: float) -> ZoneInfo | timezone:
     return ZoneInfo(timezone_name(lat, lon)) if offset is None else timezone(timedelta(hours=offset))
 
 
-def localize(dt: datetime, lat: float, lon: float, offset: float = None, is_dst: bool = None) -> datetime:
+def localize(dt: datetime, lat: float, lon: float, offset: float | None = None, is_dst: bool | None = None) -> datetime:
     """ Localizes a naive datetime based on either decimal lat/lon
     coordinates or an explicit UTC offset. """
     return dt.replace(tzinfo=get_timezone(lat, lon, offset), fold=1 if is_dst is False else 0)
 
 
-def to_datetime(dt: str | float | datetime, lat: float = None, lon: float = None, offset: float = None, is_dst: bool = None) -> datetime:
+def to_datetime(dt: str | float | datetime, lat: float | None = None, lon: float | None = None, offset: float | None = None, is_dst: bool | None = None) -> datetime:
     """ Convert an unknown into a datetime. Unknowns can be either an
     ISO-formatted string, a Julian Date, or already a datetime. """
     no_tz = (lat is None or lon is None) and offset is None
@@ -66,7 +66,7 @@ def to_datetime(dt: str | float | datetime, lat: float = None, lon: float = None
     return None
 
 
-def to_jd(dt: str | float | datetime, lat: float = None, lon: float = None, offset: float = None, is_dst: bool = None) -> float:
+def to_jd(dt: str | float | datetime, lat: float | None = None, lon: float | None = None, offset: float | None = None, is_dst: bool | None = None) -> float:
     """ Convert an unknown into a Julian date. Unknowns can be either an
     ISO-formatted string, already a Julian Date, or a datetime. """
     if isinstance(dt, float):
diff --git a/immanuel/tools/ephemeris.py b/immanuel/tools/ephemeris.py
@@ -77,7 +77,7 @@
 }
 
 
-def objects(object_list: tuple, jd: float, lat: float = None, lon: float = None, house_system: int = None, part_formula: int = None) -> dict:
+def objects(object_list: tuple, jd: float, lat: float | None = None, lon: float | None = None, house_system: int | None = None, part_formula: int | None = None) -> dict:
     """ Helper function returns a dict of all passed chart objects. """
     return _objects(
         object_list=object_list,
@@ -91,7 +91,7 @@ def objects(object_list: tuple, jd: float, lat: float = None, lon: float = None,
     )
 
 
-def armc_objects(object_list: tuple, jd: float, armc: float, lat: float = None, lon: float = None, obliquity: float = None, house_system: int = None, part_formula: int = None) -> dict:
+def armc_objects(object_list: tuple, jd: float, armc: float, lat: float | None = None, lon: float | None = None, obliquity: float | None = None, house_system: int | None = None, part_formula: int | None = None) -> dict:
     """ Helper function returns a dict of all passed chart objects
     with points & angles calculated from the passed ARMC. """
     return _objects(
@@ -106,7 +106,7 @@ def armc_objects(object_list: tuple, jd: float, armc: float, lat: float = None,
     )
 
 
-def get(index: int | str, jd: float, lat: float = None, lon: float = None, house_system: int = None, part_formula: int = None) -> dict:
+def get(index: int | str, jd: float, lat: float | None = None, lon: float | None = None, house_system: int | None = None, part_formula: int | None = None) -> dict:
     """ Helper function to retrieve an angle, house, planet, point,
     asteroid, or fixed star. """
     return _get(
@@ -121,7 +121,7 @@ def get(index: int | str, jd: float, lat: float = None, lon: float = None, house
     )
 
 
-def armc_get(index: int | str, jd: float, armc: float, lat: float = None, lon: float = None, obliquity: float = None, house_system: int = None, part_formula: int = None) -> dict:
+def armc_get(index: int | str, jd: float, armc: float, lat: float | None = None, lon: float | None = None, obliquity: float | None = None, house_system: int | None = None, part_formula: int | None = None) -> dict:
     """ Helper function to retrieve an angle, house, planet, point,
     asteroid, or fixed star with houses & angles calculated from the
     passed ARMC. """
@@ -245,7 +245,7 @@ def armc_house(index: int, armc: float, lat: float, obliquity: float, house_syst
     )
 
 
-def point(index: int, jd: float, lat: float = None, lon: float = None, house_system: int = None, part_formula: int = None) -> dict:
+def point(index: int, jd: float, lat: float | None = None, lon: float | None = None, house_system: int | None = None, part_formula: int | None = None) -> dict:
     """ Returns a calculated point by Julian date, and additionally by lat / lon
     coordinates. """
     return _point(
@@ -260,7 +260,7 @@ def point(index: int, jd: float, lat: float = None, lon: float = None, house_sys
     )
 
 
-def armc_point(index: int, jd: float, armc: float, lat: float, obliquity: float, house_system: int = None, part_formula: int = None) -> dict:
+def armc_point(index: int, jd: float, armc: float, lat: float, obliquity: float, house_system: int | None = None, part_formula: int | None = None) -> dict:
     """ Returns a calculated point by Julian date, and additionally by the
     passed ARMC. """
     return _point(
@@ -521,7 +521,7 @@ def _is_daytime(jd: float, lat: float, lon: float, armc: float, armc_obliquity:
 
 
 @cache
-def _angles_houses_vertex(jd: float, lat: float, lon: float, house_system: int, first_house_lon: float = None) -> dict:
+def _angles_houses_vertex(jd: float, lat: float, lon: float, house_system: int, first_house_lon: float | None = None) -> dict:
     """ Returns ecliptic longitudes for the houses, main angles, and the vertex,
     along with their speeds. Defaults to Placidus for main angles & vertex if
     an PLANET_ON_FIRST house system is chosen. Based on Julian date and
@@ -530,7 +530,7 @@ def _angles_houses_vertex(jd: float, lat: float, lon: float, house_system: int,
 
 
 @cache
-def _angles_houses_vertex_armc(armc: float, lat: float, obliquity: float, house_system: int, first_house_lon: float = None) -> dict:
+def _angles_houses_vertex_armc(armc: float, lat: float, obliquity: float, house_system: int, first_house_lon: float | None = None) -> dict:
     """ Returns ecliptic longitudes for the houses, main angles, and the vertex,
     along with their speeds. Defaults to Placidus for main angles & vertex if
     an PLANET_ON_FIRST house system is chosen. Based on ARMC, latitude and
@@ -637,7 +637,7 @@ def _syzygy(jd: float) -> dict:
 
 
 @cache
-def _part(index: int, jd: float, lat: float, lon: float, formula: int, armc: float = None, armc_obliquity: float = None) -> dict:
+def _part(index: int, jd: float, lat: float, lon: float, formula: int, armc: float | None = None, armc_obliquity: float | None = None) -> dict:
     """ Calculates Parts of Fortune, Spirit, and Eros. """
     sun = planet(chart.SUN, jd)
     moon = planet(chart.MOON, jd)
diff --git a/immanuel/tools/midpoint.py b/immanuel/tools/midpoint.py
@@ -15,7 +15,7 @@
 from immanuel.tools import ephemeris
 
 
-def all(objects1: dict, objects2: dict, obliquity: float = None) -> dict:
+def all(objects1: dict, objects2: dict, obliquity: float | None = None) -> dict:
     """ Takes two dicts of chart objects typically returned by the ephemeris
     module and returns the averaged data for both sets as a third dict of
     composite objects. """
@@ -27,7 +27,7 @@ def all(objects1: dict, objects2: dict, obliquity: float = None) -> dict:
     return objects
 
 
-def composite(object1: dict, object2: dict, obliquity: float = None) -> dict:
+def composite(object1: dict, object2: dict, obliquity: float | None = None) -> dict:
     """ Given two chart objects typically returned by the ephemeris module,
     this function will return a composite object. """
     object = object1 | {
