Feature/smhi class to match 0.2.0

src/smhi/smhi.py

@@ -7,7 +7,7 @@
 from geopy import distance
 from geopy.geocoders import Nominatim
 from smhi.constants import TYPE_MAP
-from smhi.metobs import Metobs
+from smhi.metobs import Data, Parameters, Periods, Stations, Versions
 
 
 class SMHI:
@@ -21,8 +21,7 @@ def __init__(self, type: str = "json", version: str = "1.0") -> None:
             version: API version
         """
         self.type = TYPE_MAP[type]
-        self.client = Metobs(type)
-        self.client.get_parameters()
+        self.parameters = Parameters(Versions())
 
     @property
     def parameters(self):
@@ -31,7 +30,7 @@ def parameters(self):
         Returns:
             parameters
         """
-        return self.client.parameters.data
+        return self.parameters.data
 
     def get_stations(self, parameter: Optional[int] = None):
         """Get stations from parameter.
@@ -42,12 +41,12 @@ def get_stations(self, parameter: Optional[int] = None):
         Returns:
             stations
         """
-        if self.client.parameters is None:
+        if self.parameters is None:
             logging.info("No parameters available.")
             return None
 
-        self.client.get_stations(parameter)
-        return self.client.stations.data
+        self.stations = Stations(self.parameters, parameter)
+        return self.stations.data
 
     def get_stations_from_title(self, title: Optional[str] = None):
         """Get stations from title.
@@ -58,12 +57,12 @@ def get_stations_from_title(self, title: Optional[str] = None):
         Returns:
             stations
         """
-        if self.client.stations is None:
+        if self.stations is None:
             logging.info("No stations available.")
             return None
 
-        self.client.get_stations(None, title)
-        return self.client.stations.data
+        self.stations = Stations(self.parameters, title)
+        return self.stations.data
 
     def find_stations_from_gps(
         self, parameter: int, latitude: float, longitude: float, dist: float = 0
@@ -144,19 +143,19 @@ def get_data(
             station: station id
             period: period to get
         """
-        data, header = self.client.get_data_from_selection(
-            parameter=parameter, station=station, period=period
-        )
+        self.stations = Stations(Parameters(Versions()), parameter)
+        self.periods = Periods(self.stations, station)
+        data = Data(self.periods)
         if interpolate > 0:
             # Find the station latitude and longitude information from Metobs
-            stat = next(
-                item for item in self.client.stations.stations if item["id"] == station
-            )
-            latitude = stat["latitude"]
-            longitude = stat["longitude"]
-
-            holes_to_fill = data[
-                data.index.to_series().diff() > data.index.to_series().diff().median()
+            # should be replaced by a self.periods.position[0].latitude
+            stat = next(item for item in self.stations.station if item.id == station)
+            latitude = stat.latitude
+            longitude = stat.longitude
+
+            holes_to_fill = data.df[
+                data.df.index.to_series().diff()
+                > data.df.index.to_series().diff().median()
             ]
             # Find stations within a given radius - set in "interpolate".
             self.find_stations_from_gps(
@@ -168,24 +167,25 @@ def get_data(
 
             # Iterate over nearby stations, starting with the closest
             for nearby_station in self.nearby_stations[1:]:
-                tmpdata, _ = self.get_data(parameter, nearby_station[0])
+                tmpdata = Data(Periods(self.stations, station))
                 for time, _ in holes_to_fill.iterrows():
-                    earliertime = data[data.index < time].index.max()
+                    earliertime = data.df[data.df.index < time].index.max()
 
                     if (
                         len(
-                            tmpdata[
-                                (tmpdata.index > earliertime) & (tmpdata.index < time)
+                            tmpdata.df[
+                                (tmpdata.df.index > earliertime)
+                                & (tmpdata.df.index < time)
                             ]
                         )
                         > 0
                     ):
-                        data = pd.concat([data, tmpdata], axis=0, join="outer")
+                        data.df = pd.concat([data.df, tmpdata.df], axis=0, join="outer")
 
                 # Re-check how many holes remain
-                holes_to_fill = data[
-                    data.index.to_series().diff()
-                    > data.index.to_series().diff().median()
+                holes_to_fill = data.df[
+                    data.df.index.to_series().diff()
+                    > data.df.index.to_series().diff().median()
                 ]
-        data = data.sort_index()
-        return data, header
+        data.df = data.df.sort_index()
+        return data