-
Notifications
You must be signed in to change notification settings - Fork 0
/
models.py
executable file
·144 lines (119 loc) · 6.34 KB
/
models.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
"""Represent models for near-Earth objects and their close approaches.
The `NearEarthObject` class represents a near-Earth object. Each has a unique
primary designation, an optional unique name, an optional diameter, and a flag
for whether the object is potentially hazardous.
The `CloseApproach` class represents a close approach to Earth by an NEO. Each
has an approach datetime, a nominal approach distance, and a relative approach
velocity.
A `NearEarthObject` maintains a collection of its close approaches, and a
`CloseApproach` maintains a reference to its NEO.
The functions that construct these objects use information extracted from the
data files from NASA, so these objects should be able to handle all of the
quirks of the data set, such as missing names and unknown diameters.
You'll edit this file in Task 1.
"""
from helpers import cd_to_datetime, datetime_to_str
class NearEarthObject:
"""A near-Earth object (NEO).
An NEO encapsulates semantic and physical parameters about the object, such
as its primary designation (required, unique), IAU name (optional), diameter
in kilometers (optional - sometimes unknown), and whether it's marked as
potentially hazardous to Earth.
A `NearEarthObject` also maintains a collection of its close approaches -
initialized to an empty collection, but eventually populated in the
`NEODatabase` constructor.
"""
def __init__(self, designation, name, diameter, hazardous, **info):
"""Create a new `NearEarthObject`.
:param designation: The primary designation.
:param name: The IAU name.
:param diameter: The diameter, in kilometers.
:param hazardous: Whether or not this NearEarthObject is potentially hazardous.
:param info: A dictionary of excess keyword arguments supplied to the constructor.
"""
# Assign information from the arguments passed to the constructor
# onto attributes named `designation`, `name`, `diameter`, and `hazardous`.
self.designation = designation
self.name = name if name else None
self.diameter = float(diameter) if diameter else float("nan")
self.hazardous = bool(hazardous)
# Create an empty initial collection of linked approaches.
self.approaches = []
@property
def fullname(self):
"""Return a representation of the full name of this NEO."""
# Use self.designation and self.name to build a fullname for this object.
return f"{self.designation} ({self.name})" if self.name else self.designation
def __str__(self):
"""Return `str(self)`."""
# Use this object's attributes to return a human-readable string representation.
return (
f"NEO {self.fullname} has a diameter of {self.diameter:.3f} km and "
f"{'is' if self.hazardous else 'is not'} potentially hazardous."
)
def __repr__(self):
"""Return `repr(self)`, a computer-readable string representation of this object."""
return (
f"NearEarthObject(designation={self.designation!r}, name={self.name!r}, "
f"diameter={self.diameter:.3f}, hazardous={self.hazardous!r})"
)
class CloseApproach:
"""A close approach to Earth by an NEO.
A `CloseApproach` encapsulates information about the NEO's close approach to
Earth, such as the date and time (in UTC) of closest approach, the nominal
approach distance in astronomical units, and the relative approach velocity
in kilometers per second.
A `CloseApproach` also maintains a reference to its `NearEarthObject` -
initially, this information (the NEO's primary designation) is saved in a
private attribute, but the referenced NEO is eventually replaced in the
`NEODatabase` constructor.
"""
def __init__(self, designation, time, distance, velocity, **info):
"""Create a new `CloseApproach`.
:param designation: The primary designation of the close approach's NEO.
:param time: The date and time, in UTC, at which the NEO passes closest to Earth.
:param distance: The nominal approach distance, in astronomical units,
of the NEO to Earth at the closest point.
:param velocity: The velocity, in kilometers per second,
of the NEO relative to Earth at the closest point.
:param info: A dictionary of excess keyword arguments supplied to the constructor.
"""
# Assign information from the arguments passed to the constructor
# onto attributes named `_designation`, `time`, `distance`, and `velocity`.
self._designation = designation
self.time = cd_to_datetime(
time
) # Use the cd_to_datetime function for this attribute.
self.distance = float(distance)
self.velocity = float(velocity)
# Create an attribute for the referenced NEO, originally None.
self.neo = None
@property
def time_str(self):
"""Return a formatted representation of this `CloseApproach`'s approach time.
The value in `self.time` should be a Python `datetime` object. While a
`datetime` object has a string representation, the default representation
includes seconds - significant figures that don't exist in our input
data set.
The `datetime_to_str` method converts a `datetime` object to a
formatted string that can be used in human-readable representations and
in serialization to CSV and JSON files.
"""
# Use this object's `.time` attribute and the `datetime_to_str` function to
# build a formatted representation of the approach time.
return datetime_to_str(self.time)
def __str__(self):
"""Return `str(self)`."""
# Use this object's attributes to return a human-readable string representation.
fullname = self.neo.fullname if self.neo else self._designation
return (
f"On {self.time_str}, '{fullname}' approaches Earth "
f"at a distance of {self.distance:.2f} au "
f"and a velocity of {self.velocity:.2f} km/s."
)
def __repr__(self):
"""Return `repr(self)`, a computer-readable string representation of this object."""
return (
f"CloseApproach(time={self.time_str!r}, distance={self.distance:.2f}, "
f"velocity={self.velocity:.2f}, neo={self.neo!r})"
)