types-PyMeeus 0.5.0.20250828__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pymeeus-stubs/Angle.pyi +95 -0
- pymeeus-stubs/Coordinates.pyi +192 -0
- pymeeus-stubs/CurveFitting.pyi +43 -0
- pymeeus-stubs/Earth.pyi +64 -0
- pymeeus-stubs/Epoch.pyi +129 -0
- pymeeus-stubs/Interpolation.pyi +42 -0
- pymeeus-stubs/Jupiter.pyi +38 -0
- pymeeus-stubs/JupiterMoons.pyi +78 -0
- pymeeus-stubs/METADATA.toml +2 -0
- pymeeus-stubs/Mars.pyi +38 -0
- pymeeus-stubs/Mercury.pyi +42 -0
- pymeeus-stubs/Minor.pyi +10 -0
- pymeeus-stubs/Moon.pyi +39 -0
- pymeeus-stubs/Neptune.pyi +30 -0
- pymeeus-stubs/Pluto.pyi +17 -0
- pymeeus-stubs/Saturn.pyi +44 -0
- pymeeus-stubs/Sun.pyi +35 -0
- pymeeus-stubs/Uranus.pyi +34 -0
- pymeeus-stubs/Venus.pyi +44 -0
- pymeeus-stubs/__init__.pyi +0 -0
- pymeeus-stubs/base.pyi +8 -0
- pymeeus-stubs/py.typed +0 -0
- types_pymeeus-0.5.0.20250828.dist-info/METADATA +38 -0
- types_pymeeus-0.5.0.20250828.dist-info/RECORD +27 -0
- types_pymeeus-0.5.0.20250828.dist-info/WHEEL +5 -0
- types_pymeeus-0.5.0.20250828.dist-info/licenses/LICENSE +237 -0
- types_pymeeus-0.5.0.20250828.dist-info/top_level.txt +1 -0
pymeeus-stubs/Angle.pyi
ADDED
|
@@ -0,0 +1,95 @@
|
|
|
1
|
+
from typing import overload
|
|
2
|
+
from typing_extensions import Self
|
|
3
|
+
|
|
4
|
+
class Angle:
|
|
5
|
+
@overload
|
|
6
|
+
def __init__(self, *, ra: bool = False) -> None: ...
|
|
7
|
+
@overload
|
|
8
|
+
def __init__(self, a: Angle, /, *, ra: bool = False) -> None: ...
|
|
9
|
+
@overload
|
|
10
|
+
def __init__(self, a: float, /, *, ra: bool = False, radians: bool = False) -> None: ...
|
|
11
|
+
@overload
|
|
12
|
+
def __init__(self, a: list[float] | tuple[float, ...], /, *, ra: bool = False, radians: bool = False) -> None: ...
|
|
13
|
+
@overload
|
|
14
|
+
def __init__(self, a1: float, a2: float, /, *, ra: bool = False) -> None: ...
|
|
15
|
+
@overload
|
|
16
|
+
def __init__(self, a1: float, a2: float, a3: float, /, *, ra: bool = False) -> None: ...
|
|
17
|
+
@overload
|
|
18
|
+
def __init__(self, a1: float, a2: float, a3: float, a4: float, /, *, ra: bool = False) -> None: ...
|
|
19
|
+
@staticmethod
|
|
20
|
+
def reduce_deg(deg: float | Angle) -> float: ...
|
|
21
|
+
@staticmethod
|
|
22
|
+
def reduce_dms(degrees: float, minutes: float, seconds: float = 0.0) -> tuple[int, int, float, float]: ...
|
|
23
|
+
@staticmethod
|
|
24
|
+
def deg2dms(deg: float | Angle) -> tuple[int, int, float, float]: ...
|
|
25
|
+
@staticmethod
|
|
26
|
+
def dms2deg(degrees: float, minutes: float, seconds: float = 0.0) -> float: ...
|
|
27
|
+
def get_tolerance(self) -> float: ...
|
|
28
|
+
def set_tolerance(self, tol: float) -> None: ...
|
|
29
|
+
def __call__(self) -> float: ...
|
|
30
|
+
@overload
|
|
31
|
+
def set(self, *, ra: bool = False) -> None: ...
|
|
32
|
+
@overload
|
|
33
|
+
def set(self, a: Angle, /, *, ra: bool = False) -> None: ...
|
|
34
|
+
@overload
|
|
35
|
+
def set(self, a: float, /, *, ra: bool = False, radians: bool = False) -> None: ...
|
|
36
|
+
@overload
|
|
37
|
+
def set(self, a: list[float] | tuple[float, ...], /, *, ra: bool = False, radians: bool = False) -> None: ...
|
|
38
|
+
@overload
|
|
39
|
+
def set(self, a1: float, a2: float, /, *, ra: bool = False) -> None: ...
|
|
40
|
+
@overload
|
|
41
|
+
def set(self, a1: float, a2: float, a3: float, /, *, ra: bool = False) -> None: ...
|
|
42
|
+
@overload
|
|
43
|
+
def set(self, a1: float, a2: float, a3: float, a4: float, /, *, ra: bool = False) -> None: ...
|
|
44
|
+
def set_radians(self, rads: float) -> None: ...
|
|
45
|
+
@overload
|
|
46
|
+
def set_ra(self) -> None: ...
|
|
47
|
+
@overload
|
|
48
|
+
def set_ra(self, a: float | Angle | list[float] | tuple[float, ...], /) -> None: ...
|
|
49
|
+
@overload
|
|
50
|
+
def set_ra(self, a1: float, a2: float, /) -> None: ...
|
|
51
|
+
@overload
|
|
52
|
+
def set_ra(self, a1: float, a2: float, a3: float, /) -> None: ...
|
|
53
|
+
@overload
|
|
54
|
+
def set_ra(self, a1: float, a2: float, a3: float, a4: float, /) -> None: ...
|
|
55
|
+
def dms_str(self, fancy: bool | None = True, n_dec: int = -1) -> str: ...
|
|
56
|
+
def get_ra(self) -> float: ...
|
|
57
|
+
def ra_str(self, fancy: bool | None = True, n_dec: int = -1) -> str: ...
|
|
58
|
+
def rad(self) -> float: ...
|
|
59
|
+
def dms_tuple(self) -> tuple[int, int, float, float]: ...
|
|
60
|
+
def ra_tuple(self) -> tuple[int, int, float, float]: ...
|
|
61
|
+
def to_positive(self) -> Self: ...
|
|
62
|
+
def __eq__(self, b: float | Angle) -> bool: ... # type: ignore[override]
|
|
63
|
+
def __ne__(self, b: float | Angle) -> bool: ... # type: ignore[override]
|
|
64
|
+
def __lt__(self, b: float | Angle) -> bool: ...
|
|
65
|
+
def __ge__(self, b: float | Angle) -> bool: ...
|
|
66
|
+
def __gt__(self, b: float | Angle) -> bool: ...
|
|
67
|
+
def __le__(self, b: float | Angle) -> bool: ...
|
|
68
|
+
def __neg__(self) -> Angle: ...
|
|
69
|
+
def __abs__(self) -> Angle: ...
|
|
70
|
+
def __mod__(self, b: float | Angle) -> Angle: ...
|
|
71
|
+
def __add__(self, b: float | Angle) -> Angle: ...
|
|
72
|
+
def __sub__(self, b: float | Angle) -> Angle: ...
|
|
73
|
+
def __mul__(self, b: float | Angle) -> Angle: ...
|
|
74
|
+
def __div__(self, b: float | Angle) -> Angle: ...
|
|
75
|
+
def __truediv__(self, b: float | Angle) -> Angle: ...
|
|
76
|
+
def __pow__(self, b: float | Angle) -> Angle: ...
|
|
77
|
+
def __imod__(self, b: float | Angle) -> Self: ...
|
|
78
|
+
def __iadd__(self, b: float | Angle) -> Self: ...
|
|
79
|
+
def __isub__(self, b: float | Angle) -> Self: ...
|
|
80
|
+
def __imul__(self, b: float | Angle) -> Self: ...
|
|
81
|
+
def __idiv__(self, b: float | Angle) -> Angle: ...
|
|
82
|
+
def __itruediv__(self, b: float | Angle) -> Self: ...
|
|
83
|
+
def __ipow__(self, b: float | Angle) -> Self: ...
|
|
84
|
+
def __rmod__(self, b: float | Angle) -> Angle: ...
|
|
85
|
+
def __radd__(self, b: float | Angle) -> Angle: ...
|
|
86
|
+
def __rsub__(self, b: float | Angle) -> Angle: ...
|
|
87
|
+
def __rmul__(self, b: float | Angle) -> Angle: ...
|
|
88
|
+
def __rdiv__(self, b: float | Angle) -> Angle: ...
|
|
89
|
+
def __rtruediv__(self, b: float | Angle) -> Angle: ...
|
|
90
|
+
def __rpow__(self, b: float | Angle) -> Angle: ...
|
|
91
|
+
def __float__(self) -> float: ...
|
|
92
|
+
def __int__(self) -> int: ...
|
|
93
|
+
def __round__(self, n: float = 0) -> Angle: ...
|
|
94
|
+
|
|
95
|
+
def main() -> None: ...
|
|
@@ -0,0 +1,192 @@
|
|
|
1
|
+
import datetime
|
|
2
|
+
from typing import Final, overload
|
|
3
|
+
|
|
4
|
+
from pymeeus.Angle import Angle
|
|
5
|
+
from pymeeus.Epoch import Epoch
|
|
6
|
+
|
|
7
|
+
NUTATION_ARG_TABLE: Final[list[list[int]]]
|
|
8
|
+
NUTATION_SINE_COEF_TABLE: Final[list[list[float]]]
|
|
9
|
+
NUTATION_COSINE_COEF_TABLE: Final[list[list[float]]]
|
|
10
|
+
|
|
11
|
+
@overload
|
|
12
|
+
def mean_obliquity(
|
|
13
|
+
a: Epoch | list[float] | tuple[float, ...] | datetime.date,
|
|
14
|
+
/,
|
|
15
|
+
*,
|
|
16
|
+
leap_seconds: float = 0,
|
|
17
|
+
local: bool = False,
|
|
18
|
+
utc: bool = False,
|
|
19
|
+
) -> Angle: ...
|
|
20
|
+
@overload
|
|
21
|
+
def mean_obliquity(
|
|
22
|
+
year: int, month: int, day: int, /, *, leap_seconds: float = 0, local: bool = False, utc: bool = False
|
|
23
|
+
) -> Angle: ...
|
|
24
|
+
@overload
|
|
25
|
+
def true_obliquity(
|
|
26
|
+
a: Epoch | list[float] | tuple[float, ...] | datetime.date,
|
|
27
|
+
/,
|
|
28
|
+
*,
|
|
29
|
+
leap_seconds: float = 0,
|
|
30
|
+
local: bool = False,
|
|
31
|
+
utc: bool = False,
|
|
32
|
+
) -> Angle: ...
|
|
33
|
+
@overload
|
|
34
|
+
def true_obliquity(
|
|
35
|
+
year: int, month: int, day: int, /, *, leap_seconds: float = 0, local: bool = False, utc: bool = False
|
|
36
|
+
) -> Angle: ...
|
|
37
|
+
@overload
|
|
38
|
+
def nutation_longitude(
|
|
39
|
+
a: Epoch | list[float] | tuple[float, ...] | datetime.date,
|
|
40
|
+
/,
|
|
41
|
+
*,
|
|
42
|
+
leap_seconds: float = 0,
|
|
43
|
+
local: bool = False,
|
|
44
|
+
utc: bool = False,
|
|
45
|
+
) -> Angle: ...
|
|
46
|
+
@overload
|
|
47
|
+
def nutation_longitude(
|
|
48
|
+
year: int, month: int, day: int, /, *, leap_seconds: float = 0, local: bool = False, utc: bool = False
|
|
49
|
+
) -> Angle: ...
|
|
50
|
+
@overload
|
|
51
|
+
def nutation_obliquity(
|
|
52
|
+
a: Epoch | list[float] | tuple[float, ...] | datetime.date,
|
|
53
|
+
/,
|
|
54
|
+
*,
|
|
55
|
+
leap_seconds: float = 0,
|
|
56
|
+
local: bool = False,
|
|
57
|
+
utc: bool = False,
|
|
58
|
+
) -> Angle: ...
|
|
59
|
+
@overload
|
|
60
|
+
def nutation_obliquity(
|
|
61
|
+
year: int, month: int, day: int, /, *, leap_seconds: float = 0, local: bool = False, utc: bool = False
|
|
62
|
+
) -> Angle: ...
|
|
63
|
+
def precession_equatorial(
|
|
64
|
+
start_epoch: Epoch,
|
|
65
|
+
final_epoch: Epoch,
|
|
66
|
+
start_ra: Angle,
|
|
67
|
+
start_dec: Angle,
|
|
68
|
+
p_motion_ra: float | Angle = 0.0,
|
|
69
|
+
p_motion_dec: float | Angle = 0.0,
|
|
70
|
+
) -> tuple[Angle, Angle]: ...
|
|
71
|
+
def precession_ecliptical(
|
|
72
|
+
start_epoch: Epoch,
|
|
73
|
+
final_epoch: Epoch,
|
|
74
|
+
start_lon: Angle,
|
|
75
|
+
start_lat: Angle,
|
|
76
|
+
p_motion_lon: float | Angle = 0.0,
|
|
77
|
+
p_motion_lat: float | Angle = 0.0,
|
|
78
|
+
) -> tuple[Angle, Angle]: ...
|
|
79
|
+
def p_motion_equa2eclip(
|
|
80
|
+
p_motion_ra: Angle, p_motion_dec: Angle, ra: Angle, dec: Angle, lat: Angle, epsilon: Angle
|
|
81
|
+
) -> tuple[float, float]: ...
|
|
82
|
+
def precession_newcomb(
|
|
83
|
+
start_epoch: Epoch,
|
|
84
|
+
final_epoch: Epoch,
|
|
85
|
+
start_ra: Angle,
|
|
86
|
+
start_dec: Angle,
|
|
87
|
+
p_motion_ra: float | Angle = 0.0,
|
|
88
|
+
p_motion_dec: float | Angle = 0.0,
|
|
89
|
+
) -> tuple[Angle, Angle]: ...
|
|
90
|
+
def motion_in_space(
|
|
91
|
+
start_ra: Angle,
|
|
92
|
+
start_dec: Angle,
|
|
93
|
+
distance: float,
|
|
94
|
+
velocity: float,
|
|
95
|
+
p_motion_ra: float | Angle,
|
|
96
|
+
p_motion_dec: float | Angle,
|
|
97
|
+
time: float,
|
|
98
|
+
) -> tuple[Angle, Angle]: ...
|
|
99
|
+
def equatorial2ecliptical(right_ascension: Angle, declination: Angle, obliquity: Angle) -> tuple[Angle, Angle]: ...
|
|
100
|
+
def ecliptical2equatorial(longitude: Angle, latitude: Angle, obliquity: Angle) -> tuple[Angle, Angle]: ...
|
|
101
|
+
def equatorial2horizontal(hour_angle: Angle, declination: Angle, geo_latitude: Angle) -> tuple[Angle, Angle]: ...
|
|
102
|
+
def horizontal2equatorial(azimuth: Angle, elevation: Angle, geo_latitude: Angle) -> tuple[Angle, Angle]: ...
|
|
103
|
+
def equatorial2galactic(right_ascension: Angle, declination: Angle) -> tuple[Angle, Angle]: ...
|
|
104
|
+
def galactic2equatorial(longitude: Angle, latitude: Angle) -> tuple[Angle, Angle]: ...
|
|
105
|
+
def parallactic_angle(hour_angle: Angle, declination: Angle, geo_latitude: Angle) -> Angle | None: ...
|
|
106
|
+
def ecliptic_horizon(local_sidereal_time: Angle, geo_latitude: Angle, obliquity: Angle) -> tuple[Angle, Angle, Angle]: ...
|
|
107
|
+
def ecliptic_equator(longitude: Angle, latitude: Angle, obliquity: Angle) -> Angle: ...
|
|
108
|
+
def diurnal_path_horizon(declination: Angle, geo_latitude: Angle) -> Angle: ...
|
|
109
|
+
def times_rise_transit_set(
|
|
110
|
+
longitude: Angle,
|
|
111
|
+
latitude: Angle,
|
|
112
|
+
alpha1: Angle,
|
|
113
|
+
delta1: Angle,
|
|
114
|
+
alpha2: Angle,
|
|
115
|
+
delta2: Angle,
|
|
116
|
+
alpha3: Angle,
|
|
117
|
+
delta3: Angle,
|
|
118
|
+
h0: Angle,
|
|
119
|
+
delta_t: float,
|
|
120
|
+
theta0: Angle,
|
|
121
|
+
) -> tuple[float, float, float] | tuple[None, None, None]: ...
|
|
122
|
+
def refraction_apparent2true(apparent_elevation: Angle, pressure: float = 1010.0, temperature: float = 10.0) -> Angle: ...
|
|
123
|
+
def refraction_true2apparent(true_elevation: Angle, pressure: float = 1010.0, temperature: float = 10.0) -> Angle: ...
|
|
124
|
+
def angular_separation(alpha1: Angle, delta1: Angle, alpha2: Angle, delta2: Angle) -> Angle: ...
|
|
125
|
+
def minimum_angular_separation(
|
|
126
|
+
alpha1_1: Angle,
|
|
127
|
+
delta1_1: Angle,
|
|
128
|
+
alpha1_2: Angle,
|
|
129
|
+
delta1_2: Angle,
|
|
130
|
+
alpha1_3: Angle,
|
|
131
|
+
delta1_3: Angle,
|
|
132
|
+
alpha2_1: Angle,
|
|
133
|
+
delta2_1: Angle,
|
|
134
|
+
alpha2_2: Angle,
|
|
135
|
+
delta2_2: Angle,
|
|
136
|
+
alpha2_3: Angle,
|
|
137
|
+
delta2_3: Angle,
|
|
138
|
+
) -> tuple[float, Angle]: ...
|
|
139
|
+
def relative_position_angle(alpha1: Angle, delta1: Angle, alpha2: Angle, delta2: Angle) -> Angle: ...
|
|
140
|
+
def planetary_conjunction(
|
|
141
|
+
alpha1_list: list[Angle] | tuple[Angle, ...],
|
|
142
|
+
delta1_list: list[Angle] | tuple[Angle, ...],
|
|
143
|
+
alpha2_list: list[Angle] | tuple[Angle, ...],
|
|
144
|
+
delta2_list: list[Angle] | tuple[Angle, ...],
|
|
145
|
+
) -> tuple[float, Angle]: ...
|
|
146
|
+
def planet_star_conjunction(
|
|
147
|
+
alpha_list: list[Angle] | tuple[Angle, ...], delta_list: list[Angle] | tuple[Angle, ...], alpha_star: Angle, delta_star: Angle
|
|
148
|
+
) -> tuple[float, Angle]: ...
|
|
149
|
+
def planet_stars_in_line(
|
|
150
|
+
alpha_list: list[Angle] | tuple[Angle, ...],
|
|
151
|
+
delta_list: list[Angle] | tuple[Angle, ...],
|
|
152
|
+
alpha_star1: Angle,
|
|
153
|
+
delta_star1: Angle,
|
|
154
|
+
alpha_star2: Angle,
|
|
155
|
+
delta_star2: Angle,
|
|
156
|
+
) -> float: ...
|
|
157
|
+
def straight_line(
|
|
158
|
+
alpha1: Angle, delta1: Angle, alpha2: Angle, delta2: Angle, alpha3: Angle, delta3: Angle
|
|
159
|
+
) -> tuple[Angle, Angle]: ...
|
|
160
|
+
def circle_diameter(alpha1: Angle, delta1: Angle, alpha2: Angle, delta2: Angle, alpha3: Angle, delta3: Angle) -> Angle: ...
|
|
161
|
+
def vsop_pos(
|
|
162
|
+
epoch: Epoch, vsop_l: list[list[list[float]]], vsop_b: list[list[list[float]]], vsop_r: list[list[list[float]]]
|
|
163
|
+
) -> tuple[Angle, Angle, float]: ...
|
|
164
|
+
def geometric_vsop_pos(
|
|
165
|
+
epoch: Epoch,
|
|
166
|
+
vsop_l: list[list[list[float]]],
|
|
167
|
+
vsop_b: list[list[list[float]]],
|
|
168
|
+
vsop_r: list[list[list[float]]],
|
|
169
|
+
tofk5: bool | None = True,
|
|
170
|
+
) -> tuple[Angle, Angle, float]: ...
|
|
171
|
+
def apparent_vsop_pos(
|
|
172
|
+
epoch: Epoch,
|
|
173
|
+
vsop_l: list[list[list[float]]],
|
|
174
|
+
vsop_b: list[list[list[float]]],
|
|
175
|
+
vsop_r: list[list[list[float]]],
|
|
176
|
+
nutation: bool | None = True,
|
|
177
|
+
) -> tuple[Angle, Angle, float]: ...
|
|
178
|
+
def apparent_position(epoch: Epoch, alpha: Angle, delta: Angle, sun_lon: Angle) -> tuple[Angle, Angle]: ...
|
|
179
|
+
def orbital_equinox2equinox(epoch0: Epoch, epoch: Epoch, i0: Angle, arg0: Angle, lon0: Angle) -> tuple[Angle, Angle, Angle]: ...
|
|
180
|
+
def kepler_equation(eccentricity: float, mean_anomaly: Angle) -> tuple[Angle, Angle]: ...
|
|
181
|
+
def orbital_elements(
|
|
182
|
+
epoch: Epoch, parameters1: list[list[float]], parameters2: list[list[float]]
|
|
183
|
+
) -> tuple[Angle, float, float, Angle, Angle, Angle]: ...
|
|
184
|
+
def velocity(r: float, a: float) -> float: ...
|
|
185
|
+
def velocity_perihelion(e: float, a: float) -> float: ...
|
|
186
|
+
def velocity_aphelion(e: float, a: float) -> float: ...
|
|
187
|
+
def length_orbit(e: float, a: float) -> float: ...
|
|
188
|
+
def passage_nodes_elliptic(omega: Angle, e: float, a: float, t: Epoch, ascending: bool | None = True) -> tuple[Epoch, float]: ...
|
|
189
|
+
def passage_nodes_parabolic(omega: Angle, q: float, t: Epoch, ascending: bool | None = True) -> tuple[Epoch, float]: ...
|
|
190
|
+
def phase_angle(sun_dist: float, earth_dist: float, sun_earth_dist: float) -> Angle: ...
|
|
191
|
+
def illuminated_fraction(sun_dist: float, earth_dist: float, sun_earth_dist: float) -> float: ...
|
|
192
|
+
def main() -> None: ...
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
from collections.abc import Callable
|
|
2
|
+
from typing import overload
|
|
3
|
+
|
|
4
|
+
from pymeeus.Angle import Angle
|
|
5
|
+
|
|
6
|
+
class CurveFitting:
|
|
7
|
+
@overload
|
|
8
|
+
def __init__(self) -> None: ...
|
|
9
|
+
@overload
|
|
10
|
+
def __init__(self, a: CurveFitting, /) -> None: ...
|
|
11
|
+
@overload
|
|
12
|
+
def __init__(self, a: list[float | Angle] | tuple[float | Angle, ...], /) -> None: ...
|
|
13
|
+
@overload
|
|
14
|
+
def __init__(
|
|
15
|
+
self, a1: list[float | Angle] | tuple[float | Angle, ...], a2: list[float | Angle] | tuple[float | Angle, ...], /
|
|
16
|
+
) -> None: ...
|
|
17
|
+
@overload
|
|
18
|
+
def __init__(
|
|
19
|
+
self, a1: float | Angle, a2: float | Angle, a3: float | Angle, a4: float | Angle, /, *rest: float | Angle
|
|
20
|
+
) -> None: ...
|
|
21
|
+
@overload
|
|
22
|
+
def set(self) -> None: ...
|
|
23
|
+
@overload
|
|
24
|
+
def set(self, a: CurveFitting, /) -> None: ...
|
|
25
|
+
@overload
|
|
26
|
+
def set(self, a: list[float | Angle] | tuple[float | Angle, ...], /) -> None: ...
|
|
27
|
+
@overload
|
|
28
|
+
def set(
|
|
29
|
+
self, a1: list[float | Angle] | tuple[float | Angle, ...], a2: list[float | Angle] | tuple[float | Angle, ...], /
|
|
30
|
+
) -> None: ...
|
|
31
|
+
@overload
|
|
32
|
+
def set(
|
|
33
|
+
self, a1: float | Angle, a2: float | Angle, a3: float | Angle, a4: float | Angle, /, *rest: float | Angle
|
|
34
|
+
) -> None: ...
|
|
35
|
+
def __len__(self) -> int: ...
|
|
36
|
+
def correlation_coeff(self) -> float: ...
|
|
37
|
+
def linear_fitting(self) -> tuple[float, float]: ...
|
|
38
|
+
def quadratic_fitting(self) -> tuple[float, float, float]: ...
|
|
39
|
+
def general_fitting(
|
|
40
|
+
self, f0: Callable[..., float], f1: Callable[..., float] = ..., f2: Callable[..., float] = ...
|
|
41
|
+
) -> tuple[float, float, float]: ...
|
|
42
|
+
|
|
43
|
+
def main() -> None: ...
|
pymeeus-stubs/Earth.pyi
ADDED
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
from typing import Final
|
|
2
|
+
|
|
3
|
+
from pymeeus.Angle import Angle
|
|
4
|
+
from pymeeus.Epoch import Epoch
|
|
5
|
+
|
|
6
|
+
VSOP87_L: Final[list[list[list[float]]]]
|
|
7
|
+
VSOP87_B: Final[list[list[list[float]]]]
|
|
8
|
+
VSOP87_R: Final[list[list[list[float]]]]
|
|
9
|
+
VSOP87_L_J2000: Final[list[list[list[float]]]]
|
|
10
|
+
VSOP87_B_J2000: Final[list[list[list[float]]]]
|
|
11
|
+
ORBITAL_ELEM: Final[list[list[float]]]
|
|
12
|
+
ORBITAL_ELEM_J2000: Final[list[list[float]]]
|
|
13
|
+
|
|
14
|
+
class Ellipsoid:
|
|
15
|
+
def __init__(self, a: float, f: float, omega: float) -> None: ...
|
|
16
|
+
def b(self) -> float: ...
|
|
17
|
+
def e(self) -> float: ...
|
|
18
|
+
|
|
19
|
+
IAU76: Final[Ellipsoid]
|
|
20
|
+
WGS84: Final[Ellipsoid]
|
|
21
|
+
|
|
22
|
+
class Earth:
|
|
23
|
+
def __init__(self, ellipsoid: Ellipsoid = ...) -> None: ...
|
|
24
|
+
def set(self, ellipsoid: Ellipsoid) -> None: ...
|
|
25
|
+
def rho(self, latitude: float | Angle) -> float: ...
|
|
26
|
+
def rho_sinphi(self, latitude: float | Angle, height: float) -> float: ...
|
|
27
|
+
def rho_cosphi(self, latitude: float | Angle, height: float) -> float: ...
|
|
28
|
+
def rp(self, latitude: float | Angle) -> float: ...
|
|
29
|
+
def linear_velocity(self, latitude: float | Angle) -> float: ...
|
|
30
|
+
def rm(self, latitude: float | Angle) -> float: ...
|
|
31
|
+
def distance(
|
|
32
|
+
self, lon1: float | Angle, lat1: float | Angle, lon2: float | Angle, lat2: float | Angle
|
|
33
|
+
) -> tuple[float, float]: ...
|
|
34
|
+
@staticmethod
|
|
35
|
+
def geometric_heliocentric_position(epoch: Epoch, tofk5: bool = True) -> tuple[Angle, Angle, float]: ...
|
|
36
|
+
@staticmethod
|
|
37
|
+
def apparent_heliocentric_position(epoch: Epoch, nutation: bool = True) -> tuple[Angle, Angle, float]: ...
|
|
38
|
+
@staticmethod
|
|
39
|
+
def geometric_heliocentric_position_j2000(epoch: Epoch, tofk5: bool = True) -> tuple[Angle, Angle, float]: ...
|
|
40
|
+
@staticmethod
|
|
41
|
+
def orbital_elements_mean_equinox(epoch: Epoch) -> tuple[Angle, float, float, Angle, Angle, Angle]: ...
|
|
42
|
+
@staticmethod
|
|
43
|
+
def orbital_elements_j2000(epoch: Epoch) -> tuple[Angle, float, float, Angle, Angle, Angle]: ...
|
|
44
|
+
@staticmethod
|
|
45
|
+
def perihelion_aphelion(epoch: Epoch, perihelion: bool | None = True) -> Epoch: ...
|
|
46
|
+
@staticmethod
|
|
47
|
+
def passage_nodes(epoch: Epoch, ascending: bool = True) -> tuple[Epoch, float]: ...
|
|
48
|
+
@staticmethod
|
|
49
|
+
def parallax_correction(
|
|
50
|
+
right_ascension: Angle, declination: Angle, latitude: Angle, distance: float, hour_angle: Angle, height: float = 0.0
|
|
51
|
+
) -> tuple[Angle, Angle]: ...
|
|
52
|
+
@staticmethod
|
|
53
|
+
def parallax_ecliptical(
|
|
54
|
+
longitude: Angle,
|
|
55
|
+
latitude: Angle,
|
|
56
|
+
semidiameter: Angle,
|
|
57
|
+
obs_lat: Angle,
|
|
58
|
+
obliquity: Angle,
|
|
59
|
+
sidereal_time: Angle,
|
|
60
|
+
distance: float,
|
|
61
|
+
height: float = 0.0,
|
|
62
|
+
) -> tuple[Angle, Angle, Angle]: ...
|
|
63
|
+
|
|
64
|
+
def main() -> None: ...
|
pymeeus-stubs/Epoch.pyi
ADDED
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
import datetime
|
|
2
|
+
from typing import Final, Literal, overload
|
|
3
|
+
from typing_extensions import Self
|
|
4
|
+
|
|
5
|
+
from pymeeus.Angle import Angle
|
|
6
|
+
|
|
7
|
+
DAY2SEC: Final = 86400.0
|
|
8
|
+
DAY2MIN: Final = 1440.0
|
|
9
|
+
DAY2HOURS: Final = 24.0
|
|
10
|
+
LEAP_TABLE: Final[dict[float, int]]
|
|
11
|
+
|
|
12
|
+
class Epoch:
|
|
13
|
+
@overload
|
|
14
|
+
def __init__(self) -> None: ...
|
|
15
|
+
@overload
|
|
16
|
+
def __init__(
|
|
17
|
+
self, year: int, month: int, day: int, /, *time: float, leap_seconds: float = 0, local: bool = False, utc: bool = False
|
|
18
|
+
) -> None: ...
|
|
19
|
+
@overload
|
|
20
|
+
def __init__(
|
|
21
|
+
self,
|
|
22
|
+
a: float | Epoch | list[float] | tuple[float, ...] | datetime.date,
|
|
23
|
+
/,
|
|
24
|
+
*,
|
|
25
|
+
leap_seconds: float = 0,
|
|
26
|
+
local: bool = False,
|
|
27
|
+
utc: bool = False,
|
|
28
|
+
) -> None: ...
|
|
29
|
+
def __hash__(self) -> int: ...
|
|
30
|
+
@overload
|
|
31
|
+
def set(self) -> None: ...
|
|
32
|
+
@overload
|
|
33
|
+
def set(
|
|
34
|
+
self, year: int, month: int, day: int, /, *time: float, leap_seconds: float = 0, local: bool = False, utc: bool = False
|
|
35
|
+
) -> None: ...
|
|
36
|
+
@overload
|
|
37
|
+
def set(
|
|
38
|
+
self,
|
|
39
|
+
a: float | Epoch | list[float] | tuple[float, ...] | datetime.date,
|
|
40
|
+
/,
|
|
41
|
+
*,
|
|
42
|
+
leap_seconds: float = 0,
|
|
43
|
+
local: bool = False,
|
|
44
|
+
utc: bool = False,
|
|
45
|
+
) -> None: ...
|
|
46
|
+
@overload
|
|
47
|
+
@overload
|
|
48
|
+
@staticmethod
|
|
49
|
+
def check_input_date(
|
|
50
|
+
a: Epoch | list[float] | tuple[float, ...] | datetime.date,
|
|
51
|
+
/,
|
|
52
|
+
*,
|
|
53
|
+
leap_seconds: float = 0,
|
|
54
|
+
local: bool = False,
|
|
55
|
+
utc: bool = False,
|
|
56
|
+
) -> Epoch: ...
|
|
57
|
+
@overload
|
|
58
|
+
@staticmethod
|
|
59
|
+
def check_input_date(
|
|
60
|
+
year: int, month: int, day: int, /, *, leap_seconds: float = 0, local: bool = False, utc: bool = False
|
|
61
|
+
) -> Epoch: ...
|
|
62
|
+
@staticmethod
|
|
63
|
+
def is_julian(year: int, month: int, day: int) -> bool: ...
|
|
64
|
+
def julian(self) -> bool: ...
|
|
65
|
+
@overload
|
|
66
|
+
@staticmethod
|
|
67
|
+
def get_month(month: float | str, as_string: Literal[True]) -> str: ...
|
|
68
|
+
@overload
|
|
69
|
+
@staticmethod
|
|
70
|
+
def get_month(month: float | str, as_string: Literal[False] | None = False) -> int: ...
|
|
71
|
+
@staticmethod
|
|
72
|
+
def is_leap(year: float) -> bool: ...
|
|
73
|
+
def leap(self) -> bool: ...
|
|
74
|
+
@staticmethod
|
|
75
|
+
def get_doy(yyyy: int, mm: int, dd: int) -> float: ...
|
|
76
|
+
def doy(self) -> float: ...
|
|
77
|
+
@staticmethod
|
|
78
|
+
def doy2date(year: int, doy: float) -> tuple[int, int, float]: ...
|
|
79
|
+
@staticmethod
|
|
80
|
+
def leap_seconds(year: int, month: int) -> int: ...
|
|
81
|
+
@staticmethod
|
|
82
|
+
def get_last_leap_second() -> tuple[int, int, float, int]: ...
|
|
83
|
+
@staticmethod
|
|
84
|
+
def utc2local() -> float: ...
|
|
85
|
+
@staticmethod
|
|
86
|
+
def easter(year: float) -> tuple[int, int]: ...
|
|
87
|
+
@staticmethod
|
|
88
|
+
def jewish_pesach(year: float) -> tuple[int, int]: ...
|
|
89
|
+
@staticmethod
|
|
90
|
+
def moslem2gregorian(year: float, month: float, day: float) -> tuple[int, int, int]: ...
|
|
91
|
+
@staticmethod
|
|
92
|
+
def gregorian2moslem(year: float, month: float, day: float) -> tuple[int, int, int]: ...
|
|
93
|
+
def get_date(self, *, utc: bool = False, leap_seconds: float = 0.0, local: bool = ...) -> tuple[int, int, float]: ...
|
|
94
|
+
def get_full_date(
|
|
95
|
+
self, *, utc: bool = False, leap_seconds: float = 0.0, local: bool = ...
|
|
96
|
+
) -> tuple[int, int, int, int, int, float]: ...
|
|
97
|
+
@staticmethod
|
|
98
|
+
def tt2ut(year: int, month: int) -> float: ...
|
|
99
|
+
@overload
|
|
100
|
+
def dow(self, as_string: Literal[True]) -> str: ...
|
|
101
|
+
@overload
|
|
102
|
+
def dow(self, as_string: Literal[False] | None = False) -> int: ...
|
|
103
|
+
def mean_sidereal_time(self) -> float: ...
|
|
104
|
+
def apparent_sidereal_time(self, true_obliquity: float | Angle, nutation_longitude: float | Angle) -> float: ...
|
|
105
|
+
def mjd(self) -> float: ...
|
|
106
|
+
def jde(self) -> float: ...
|
|
107
|
+
def year(self) -> float: ...
|
|
108
|
+
def rise_set(self, latitude: Angle, longitude: Angle, altitude: float = 0.0) -> tuple[Epoch, Epoch]: ...
|
|
109
|
+
def __call__(self) -> float: ...
|
|
110
|
+
def __add__(self, b: float) -> Epoch: ...
|
|
111
|
+
@overload
|
|
112
|
+
def __sub__(self, b: float) -> Epoch: ...
|
|
113
|
+
@overload
|
|
114
|
+
def __sub__(self, b: Epoch) -> float: ...
|
|
115
|
+
def __iadd__(self, b: float) -> Self: ...
|
|
116
|
+
def __isub__(self, b: float) -> Self: ... # type: ignore[misc] # __sub__ and __isub__ are incompatible
|
|
117
|
+
def __radd__(self, b: float) -> Epoch: ...
|
|
118
|
+
def __int__(self) -> int: ...
|
|
119
|
+
def __float__(self) -> float: ...
|
|
120
|
+
def __eq__(self, b: float | Epoch) -> bool: ... # type: ignore[override]
|
|
121
|
+
def __ne__(self, b: float | Epoch) -> bool: ... # type: ignore[override]
|
|
122
|
+
def __lt__(self, b: float | Epoch) -> bool: ...
|
|
123
|
+
def __ge__(self, b: float | Epoch) -> bool: ...
|
|
124
|
+
def __gt__(self, b: float | Epoch) -> bool: ...
|
|
125
|
+
def __le__(self, b: float | Epoch) -> bool: ...
|
|
126
|
+
|
|
127
|
+
JDE2000: Epoch
|
|
128
|
+
|
|
129
|
+
def main() -> None: ...
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
from typing import overload
|
|
2
|
+
|
|
3
|
+
from pymeeus.Angle import Angle
|
|
4
|
+
|
|
5
|
+
class Interpolation:
|
|
6
|
+
@overload
|
|
7
|
+
def __init__(self) -> None: ...
|
|
8
|
+
@overload
|
|
9
|
+
def __init__(self, a: Interpolation, /) -> None: ...
|
|
10
|
+
@overload
|
|
11
|
+
def __init__(self, a: list[float | Angle] | tuple[float | Angle, ...], /) -> None: ...
|
|
12
|
+
@overload
|
|
13
|
+
def __init__(
|
|
14
|
+
self, a1: list[float | Angle] | tuple[float | Angle, ...], a2: list[float | Angle] | tuple[float | Angle, ...], /
|
|
15
|
+
) -> None: ...
|
|
16
|
+
@overload
|
|
17
|
+
def __init__(
|
|
18
|
+
self, a1: float | Angle, a2: float | Angle, a3: float | Angle, a4: float | Angle, /, *rest: float | Angle
|
|
19
|
+
) -> None: ...
|
|
20
|
+
@overload
|
|
21
|
+
def set(self) -> None: ...
|
|
22
|
+
@overload
|
|
23
|
+
def set(self, a: Interpolation, /) -> None: ...
|
|
24
|
+
@overload
|
|
25
|
+
def set(self, a: list[float | Angle] | tuple[float | Angle, ...], /) -> None: ...
|
|
26
|
+
@overload
|
|
27
|
+
def set(
|
|
28
|
+
self, a1: list[float | Angle] | tuple[float | Angle, ...], a2: list[float | Angle] | tuple[float | Angle, ...], /
|
|
29
|
+
) -> None: ...
|
|
30
|
+
@overload
|
|
31
|
+
def set(
|
|
32
|
+
self, a1: float | Angle, a2: float | Angle, a3: float | Angle, a4: float | Angle, /, *rest: float | Angle
|
|
33
|
+
) -> None: ...
|
|
34
|
+
def __len__(self) -> int: ...
|
|
35
|
+
def get_tolerance(self) -> float: ...
|
|
36
|
+
def set_tolerance(self, tol: float) -> None: ...
|
|
37
|
+
def __call__(self, x: float | Angle) -> float | Angle: ...
|
|
38
|
+
def derivative(self, x: float | Angle) -> float: ...
|
|
39
|
+
def root(self, xl: float | Angle = 0, xh: float | Angle = 0, max_iter: int = 1000) -> float | Angle: ...
|
|
40
|
+
def minmax(self, xl: float | Angle = 0, xh: float | Angle = 0, max_iter: int = 1000) -> float | Angle: ...
|
|
41
|
+
|
|
42
|
+
def main() -> None: ...
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
from typing import Final
|
|
2
|
+
|
|
3
|
+
from pymeeus.Angle import Angle
|
|
4
|
+
from pymeeus.Epoch import Epoch
|
|
5
|
+
|
|
6
|
+
VSOP87_L: Final[list[list[list[float]]]]
|
|
7
|
+
VSOP87_B: Final[list[list[list[float]]]]
|
|
8
|
+
VSOP87_R: Final[list[list[list[float]]]]
|
|
9
|
+
ORBITAL_ELEM: Final[list[list[float]]]
|
|
10
|
+
ORBITAL_ELEM_J2000: Final[list[list[float]]]
|
|
11
|
+
|
|
12
|
+
class Jupiter:
|
|
13
|
+
@staticmethod
|
|
14
|
+
def geometric_heliocentric_position(epoch: Epoch, tofk5: bool | None = True) -> tuple[Angle, Angle, float]: ...
|
|
15
|
+
@staticmethod
|
|
16
|
+
def apparent_heliocentric_position(epoch: Epoch) -> tuple[Angle, Angle, float]: ...
|
|
17
|
+
@staticmethod
|
|
18
|
+
def orbital_elements_mean_equinox(epoch: Epoch) -> tuple[Angle, float, float, Angle, Angle, Angle]: ...
|
|
19
|
+
@staticmethod
|
|
20
|
+
def orbital_elements_j2000(epoch: Epoch) -> tuple[Angle, float, float, Angle, Angle, Angle]: ...
|
|
21
|
+
@staticmethod
|
|
22
|
+
def geocentric_position(epoch: Epoch) -> tuple[Angle, Angle, Angle]: ...
|
|
23
|
+
@staticmethod
|
|
24
|
+
def conjunction(epoch: Epoch) -> Epoch: ...
|
|
25
|
+
@staticmethod
|
|
26
|
+
def opposition(epoch: Epoch) -> Epoch: ...
|
|
27
|
+
@staticmethod
|
|
28
|
+
def station_longitude_1(epoch: Epoch) -> Epoch: ...
|
|
29
|
+
@staticmethod
|
|
30
|
+
def station_longitude_2(epoch: Epoch) -> Epoch: ...
|
|
31
|
+
@staticmethod
|
|
32
|
+
def perihelion_aphelion(epoch: Epoch, perihelion: bool | None = True) -> Epoch: ...
|
|
33
|
+
@staticmethod
|
|
34
|
+
def passage_nodes(epoch: Epoch, ascending: bool = True) -> tuple[Epoch, float]: ...
|
|
35
|
+
@staticmethod
|
|
36
|
+
def magnitude(sun_dist: float, earth_dist: float) -> float: ...
|
|
37
|
+
|
|
38
|
+
def main() -> None: ...
|
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
from typing import Literal, overload
|
|
2
|
+
|
|
3
|
+
from pymeeus.Angle import Angle
|
|
4
|
+
from pymeeus.Epoch import Epoch
|
|
5
|
+
|
|
6
|
+
class JupiterMoons:
|
|
7
|
+
@staticmethod
|
|
8
|
+
def jupiter_system_angles(epoch: Epoch) -> tuple[float, float]: ...
|
|
9
|
+
@staticmethod
|
|
10
|
+
def rectangular_positions_jovian_equatorial(
|
|
11
|
+
epoch: Epoch, tofk5: bool = True, solar: bool = False, do_correction: bool = True
|
|
12
|
+
) -> tuple[
|
|
13
|
+
tuple[float, float, float], tuple[float, float, float], tuple[float, float, float], tuple[float, float, float]
|
|
14
|
+
]: ...
|
|
15
|
+
@overload
|
|
16
|
+
@staticmethod
|
|
17
|
+
def apparent_rectangular_coordinates(
|
|
18
|
+
epoch: Epoch,
|
|
19
|
+
X: float,
|
|
20
|
+
Y: float,
|
|
21
|
+
Z: float,
|
|
22
|
+
OMEGA: float,
|
|
23
|
+
psi: float,
|
|
24
|
+
i: float,
|
|
25
|
+
lambda_0: float,
|
|
26
|
+
beta_0: float,
|
|
27
|
+
D: float = 0,
|
|
28
|
+
isFictional: Literal[True] = ...,
|
|
29
|
+
) -> float: ...
|
|
30
|
+
@overload
|
|
31
|
+
@staticmethod
|
|
32
|
+
def apparent_rectangular_coordinates(
|
|
33
|
+
epoch: Epoch,
|
|
34
|
+
X: float,
|
|
35
|
+
Y: float,
|
|
36
|
+
Z: float,
|
|
37
|
+
OMEGA: float,
|
|
38
|
+
psi: float,
|
|
39
|
+
i: float,
|
|
40
|
+
lambda_0: float,
|
|
41
|
+
beta_0: float,
|
|
42
|
+
D: float = 0,
|
|
43
|
+
isFictional: Literal[False] | None = False,
|
|
44
|
+
) -> tuple[float, float, float]: ...
|
|
45
|
+
@staticmethod
|
|
46
|
+
def calculate_delta(
|
|
47
|
+
epoch: Epoch,
|
|
48
|
+
) -> tuple[float, float, Angle, Angle, float] | tuple[float, float, Literal[0], Literal[0], Literal[0]]: ...
|
|
49
|
+
@overload
|
|
50
|
+
@staticmethod
|
|
51
|
+
def correct_rectangular_positions(
|
|
52
|
+
R: float, i_sat: int, DELTA: float, X_coordinate: list[float] | tuple[float, float, float]
|
|
53
|
+
) -> tuple[float, float, float]: ...
|
|
54
|
+
@overload
|
|
55
|
+
@staticmethod
|
|
56
|
+
def correct_rectangular_positions(
|
|
57
|
+
R: float, i_sat: int, DELTA: float, X_coordinate: float, Y_coordinate: float = 0, Z_coordinate: float = 0
|
|
58
|
+
) -> tuple[float, float, float]: ...
|
|
59
|
+
@overload
|
|
60
|
+
@staticmethod
|
|
61
|
+
def check_phenomena(epoch: Epoch, check_all: Literal[True] = True, i_sat: int = 0) -> list[list[float]]: ...
|
|
62
|
+
@overload
|
|
63
|
+
@staticmethod
|
|
64
|
+
def check_phenomena(epoch: Epoch, check_all: Literal[False] | None, i_sat: int = 0) -> tuple[float, float]: ...
|
|
65
|
+
@staticmethod
|
|
66
|
+
def is_phenomena(epoch: Epoch) -> list[list[bool]]: ...
|
|
67
|
+
@staticmethod
|
|
68
|
+
def check_coordinates(X: float, Y: float) -> float: ...
|
|
69
|
+
@staticmethod
|
|
70
|
+
def check_occultation(
|
|
71
|
+
X: float = 0, Y: float = 0, Z: float = 0, epoch: Epoch | None = None, i_sat: int | None = None
|
|
72
|
+
) -> float: ...
|
|
73
|
+
@staticmethod
|
|
74
|
+
def check_eclipse(
|
|
75
|
+
X_0: float = 0, Y_0: float = 0, Z_0: float = 0, epoch: Epoch | None = None, i_sat: int | None = None
|
|
76
|
+
) -> float: ...
|
|
77
|
+
|
|
78
|
+
def main() -> None: ...
|