ocstrack 0.1.0__py3-none-any.whl

ocstrack/Satellite/get_sat.py

@@ -0,0 +1,369 @@
+import os
+import requests
+import logging
+import shutil
+import time
+
+import xarray as xr
+
+from datetime import datetime, timedelta
+from typing import Union, Optional, List
+from tqdm import tqdm
+
+from .urls import URL_TEMPLATES
+
+
+logging.basicConfig(
+    level=logging.WARNING,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),  # Print logs to the console
+        # logging.FileHandler('get_sat.log', mode='w')
+    ]
+)
+_logger = logging.getLogger()
+
+
+def generate_daily_dates(start_date_str: str,
+                         end_date_str: str) -> List[str]:
+    """
+    This function generates a list of formated
+    dates between the start and end dates.
+
+    Args:
+        start_date_str: String with dates as 'YYYY-MM-DD'
+        end_date_str: String with dates as 'YYYY-MM-DD'
+
+    Returns:
+        List of formated dates (daily).
+    """
+
+    start_date = datetime.strptime(start_date_str,
+                                   '%Y-%m-%d')
+    end_date = datetime.strptime(end_date_str,
+                                 '%Y-%m-%d')
+
+    return [(start_date + timedelta(days=i)).strftime('%Y%m%d')
+            for i in range((end_date - start_date).days + 1)]
+
+
+def download_sat_data(dates_str: List[str],
+                      url_template: str,
+                      raw_dir: str,
+                      sat: str,
+                      retries: int = 1,
+                      delay: int = 5) -> List[str]:
+    """
+    This function downloads the satellite data
+
+    Parameters
+    ----------
+        dates_str: List with all the dates data will be downloaded for
+        url_template: from urls.py
+        raw_dir: path to where the raw sat data will be saved
+        retries: how many times will it try to download the data
+        delay: how long will it wait to try the download again
+
+    Returns
+    -------
+        List of paths to the downlaoded satellite files.
+    """
+    os.makedirs(raw_dir, exist_ok=True)
+    raw_files = []
+
+    for date_str in tqdm(dates_str, desc=f"Downloading {sat} data..."):
+        url = f"{url_template}{date_str}.nc"
+        filename = os.path.basename(url)
+        raw_path = os.path.join(raw_dir, filename)
+
+        if not os.path.exists(raw_path):
+            for attempt in range(retries):
+                try:
+                    with requests.get(url, stream=True) as r:
+                        r.raise_for_status()
+                        with open(raw_path, 'wb') as f:
+                            for chunk in r.iter_content(chunk_size=8192):
+                                f.write(chunk)
+                    _logger.info(f"Downloaded {filename}")
+                    break
+                except requests.RequestException as e:
+                    _logger.warning(f"Attempt {attempt+1}/{retries} \
+                                    failed for {url}: {e}")
+                    time.sleep(delay)
+            else:
+                _logger.error(f"Failed to download {filename} after \
+                              {retries} attempts.")
+        else:
+            _logger.info(f"File already exists: {filename}")
+        raw_files.append(raw_path)
+
+    return raw_files
+
+def crop_by_box(dataset: xr.Dataset,
+              lat_min: float,
+              lat_max: float,
+              lon_min: float,
+              lon_max: float) -> xr.Dataset:
+    """
+    Crops xarray data based on lats and lons
+
+    Parameters
+    ----------
+        lat_min: float/int of mininum latitude
+        lat_max: float/int of maximum latitude
+        lon_min: float/int of mininum longitude
+        lon_max: float/int of maximum latitude
+    Returns
+    -------
+        xarray object of the cropped data
+
+    Notes
+    -----
+        Satellite data uses the -180 to 180 standard
+        If you want to cross the meridian, then pass a lon_min > lon_max
+        
+    """
+    # Check if latitude and longitude coordinates are in the dataset
+    if 'lat' not in dataset or 'lon' not in dataset:
+        raise ValueError("Dataset does not contain lat or lon dimensions")
+
+    if lon_min < lon_max:
+        lon_mask = (dataset.lon >= lon_min) & (dataset.lon <= lon_max)
+    else:
+        lon_mask = (dataset.lon >= lon_min) | (dataset.lon <= lon_max)
+
+    lat_mask = (dataset.lat >= lat_min) & (dataset.lat <= lat_max)
+    cropped = dataset.where(lat_mask & lon_mask, drop=True)
+
+    return cropped
+
+def crop_by_shape():
+    """
+    To be implemented
+    """
+    pass
+
+def crop_sat_data(file_paths: List[str],
+                  cropped_dir: str,
+                  lat_min: float,
+                  lat_max: float,
+                  lon_min: float,
+                  lon_max: float) -> List[xr.Dataset]:
+    """
+    Handles the satellite data cropping
+    Crops and saves all the satellite data
+
+    Parameters
+    ----------
+        lat_min: float/int of mininum latitude
+        lat_max: float/int of maximum latitude
+        lon_min: float/int of mininum longitude
+        lon_max: float/int of maximum latitude
+
+    Returns
+    -------
+        xarray object of the cropped data
+
+    Notes
+    -----
+        Satellite data uses the -180 to 180 standard
+        If you want to change the longitudes, use util.convert_longitude(sat_data.lon,mode=?)
+    """
+    os.makedirs(cropped_dir, exist_ok=True)
+    cropped_datasets = []
+
+    for file_path in tqdm(file_paths, desc="Cropping"):
+        try:
+            with xr.open_dataset(file_path) as ds:
+                ds.load()
+                cropped = crop_by_box(ds, lat_min, lat_max, lon_min, lon_max)
+                if cropped.dims and all(size > 0 for size in cropped.sizes.values()):
+                    out_path = os.path.join(cropped_dir,
+                                            f"cropped_\
+                                                {os.path.basename(file_path)}")
+                    cropped.to_netcdf(out_path)
+                    _logger.info(f"Saved {out_path}")
+                    cropped_datasets.append(cropped)
+                else:
+                    _logger.warning(f"Skipping empty cropped dataset: \
+                                    {file_path}")
+        except Exception as e:
+            _logger.warning(f"Failed to crop \
+                            {file_path}: {type(e).__name__} - {e}")
+
+    return cropped_datasets
+
+
+def concat_sat_data(datasets: List[xr.Dataset],
+                    output_path: str,
+                    sat: str) -> Optional[xr.Dataset]:
+    """
+    Handles the satellite data concatenation
+    Concat and saves all the satellite data on the datasets list
+
+    Parameters
+    ----------
+        datasets: List xr satellite data to be concatenated
+        output_path: path to where the concatenated data will be saved
+        sat: name of the satellite
+
+    Returns
+    ----------
+        xarray object of the concatenated data
+    """
+    if not datasets:
+        _logger.warning("No datasets to concatenate.")
+        return None
+
+    try:
+        concat_ds = xr.concat(datasets, dim='time')
+        concat_ds = concat_ds.assign_coords(source=sat)
+        concat_ds.to_netcdf(output_path)
+        _logger.info(f"Concatenated dataset saved to {output_path}")
+        return concat_ds
+    except Exception as e:
+        _logger.warning(f"Failed to concatenate datasets: \
+                        {type(e).__name__} - {e}")
+        return None
+
+
+def get_per_sat(start_date: str,
+         end_date: str,
+         sat: str,
+         output_dir: Union[str, os.PathLike],
+         lat_min: Optional[float] = None,
+         lat_max: Optional[float] = None,
+         lon_min: Optional[float] = None,
+         lon_max: Optional[float] = None,
+         concat: bool = True,
+         clean_raw: bool = False,
+         clean_cropped: bool = False) -> Optional[xr.Dataset]:
+    """
+    Download, crop, and optionally concatenate satellite data.
+
+    Parameters
+    ----------
+        start_date: Start date in 'YYYY-MM-DD'
+        end_date: End date in 'YYYY-MM-DD'
+        sat: Satellite key for URL_TEMPLATES
+        output_dir: Directory to save files
+        lat_min, lat_max, lon_min, lon_max: Optional cropping bounds
+        concat: Save a single concatenated output
+        clean_raw: Delete raw files after processing
+        clean_cropped: Delete cropped files after processing
+
+    Returns
+    ----------
+        xarray.Dataset if concatenated, otherwise None
+    """
+    try:
+        url_template = URL_TEMPLATES[sat]
+    except KeyError:
+        raise ValueError(f"Unknown satellite key: {sat}")
+
+    output_dir = os.path.join(output_dir, sat)
+    raw_dir = os.path.join(output_dir, "raw")
+    cropped_dir = os.path.join(output_dir, "cropped")
+    os.makedirs(output_dir, exist_ok=True)
+
+    cropping_enabled = None not in (lat_min, lat_max, lon_min, lon_max)
+    dates_str = generate_daily_dates(start_date, end_date)
+
+    raw_files = download_sat_data(dates_str, url_template, raw_dir, sat)
+
+    datasets_to_concat = []
+    if cropping_enabled:
+        datasets_to_concat = crop_sat_data(raw_files,
+                                           cropped_dir,
+                                           lat_min,
+                                           lat_max,
+                                           lon_min,
+                                           lon_max)
+    else:
+        for file_path in raw_files:
+            try:
+                with xr.open_dataset(file_path) as ds:
+                    ds.load()
+                    datasets_to_concat.append(ds)
+            except Exception as e:
+                _logger.warning(f"Failed to load \
+                                {file_path}: {type(e).__name__} - {e}")
+
+    final_dataset = None
+    if concat and datasets_to_concat:
+        concat_filename = f"concat_{'cropped_' if cropping_enabled else ''}{sat}_{start_date}_{end_date}.nc"
+        concat_path = os.path.join(output_dir, concat_filename)
+        final_dataset = concat_sat_data(datasets_to_concat, concat_path, sat)
+
+    if clean_raw and os.path.exists(raw_dir):
+        shutil.rmtree(raw_dir)
+        _logger.info("Raw files removed.")
+
+    if clean_cropped and os.path.exists(cropped_dir):
+        shutil.rmtree(cropped_dir)
+        _logger.info("Cropped files removed.")
+
+    return final_dataset
+
+def get_multi_sat(start_date: str,
+         end_date: str,
+         sat_list: List,
+         output_dir: Union[str, os.PathLike],
+         lat_min: Optional[float] = None,
+         lat_max: Optional[float] = None,
+         lon_min: Optional[float] = None,
+         lon_max: Optional[float] = None,
+         concat: bool = True,
+         clean_raw: bool = True,
+         clean_cropped: bool = True) -> Optional[xr.Dataset]:
+    """
+    Run download and processing for multiple satellites.
+
+    Parameters
+    ----------
+        start_date: Start date in 'YYYY-MM-DD'
+        end_date: End date in 'YYYY-MM-DD'
+        sat: Satellite key for URL_TEMPLATES
+        output_dir: Directory to save files
+        lat_min, lat_max, lon_min, lon_max: Optional cropping bounds
+        concat: Save a single concatenated output
+        clean_raw: Delete raw files after processing
+
+    Returns
+    ----------
+        xarray.Dataset if concatenated, otherwise None
+    """
+
+    all_sat = []
+    for sat in sat_list:
+        concat_ds = get_per_sat(start_date,
+                            end_date,
+                            sat,
+                            output_dir,
+                            lat_min,
+                            lat_max,
+                            lon_min,
+                            lon_max,
+                            concat=concat,
+                            clean_raw=clean_raw,
+                            clean_cropped=clean_cropped)
+        if concat_ds is not None:
+            all_sat.append(concat_ds)
+
+    if all_sat:
+        try:
+            multisat_filename = f"multisat_{'cropped_' if lat_min is not None else ''}{start_date}_{end_date}.nc"
+            multisat_path = os.path.join(output_dir, multisat_filename)
+            all_sat_ds = xr.concat(all_sat, dim='time')
+            all_sat_ds.to_netcdf(multisat_path)
+            _logger.info(f"Concatenated multisat dataset saved to \
+                         {multisat_path}")
+            return all_sat_ds
+        except Exception as e:
+            _logger.warning(f"Failed to concatenate all satellite datasets: \
+                            {type(e).__name__} - {e}")
+    else:
+        _logger.warning("No satellite datasets were successfully processed.")
+
+    return None
+

ocstrack/Satellite/satellite.py

@@ -0,0 +1,103 @@
+import xarray as xr
+import numpy as np
+
+from typing import Union
+
+class SatelliteData:
+    """
+    Satellite altimetry data handler.
+
+    Loads a NetCDF file containing satellite-derived variables such as
+    significant wave height (SWH), sea level anomaly (SLA), and metadata.
+    
+    Provides accessor properties and time filtering functionality.
+
+    Methods
+    -------
+    filter_by_time(start_date, end_date)
+        Restrict the dataset to a specific time range
+    """
+    def __init__(self, filepath: str):
+        """
+        Initialize the SatelliteData object by loading a NetCDF dataset.
+
+        Parameters
+        ----------
+        filepath : str
+            Path to the satellite NetCDF file
+
+        Raises
+        ------
+        ValueError
+            If required variables are missing from the dataset
+        """
+        self.ds = xr.open_dataset(filepath)
+
+        # Check essential variables exist
+        required_vars = ['time', 'lon', 'lat', 'swh', 'sla', 'source']
+        missing = [v for v in required_vars if v not in self.ds.variables]
+        if missing:
+            raise ValueError(f"Missing required variables in dataset: {missing}")
+
+    @property
+    def time(self):
+        return self.ds.time.values
+
+    @property
+    def lon(self):
+        return self.ds.lon.values
+    @lon.setter
+    def lon(self, new_lon: Union[np.ndarray, list]):
+        if len(new_lon) != len(self.ds.lon):
+            raise ValueError("New longitude array must match existing size.")
+        self.ds['lon'] = ('time', np.array(new_lon))
+
+    @property
+    def lat(self):
+        return self.ds.lat.values
+    @lat.setter
+    def lat(self, new_lat: Union[np.ndarray, list]):
+        if len(new_lat) != len(self.ds.lat):
+            raise ValueError("New latitude array must match existing size.")
+        self.ds['lat'] = ('time', np.array(new_lat))
+        
+    @property
+    def swh(self):
+        return self.ds.swh.values
+
+    @property
+    def sla(self):
+        return self.ds.sla.values
+
+    @property
+    def source(self):
+        return self.ds.source.values
+
+    def filter_by_time(self,
+                       start_date: str,
+                       end_date: str) -> None:
+        """
+        Filter the dataset by time range.
+
+        Parameters
+        ----------
+        start_date : str
+            ISO 8601 string representing the start date
+        end_date : str
+            ISO 8601 string representing the end date
+
+        Notes
+        -----
+        The method converts time variables to datetime64 and ensures the time
+        dimension is sorted before filtering.
+        """
+        # Convert to datetime for safety
+        start = np.datetime64(start_date)
+        end = np.datetime64(end_date)
+
+        # Ensure time is datetime64 and sorted
+        if not np.issubdtype(self.ds['time'].dtype, np.datetime64):
+            self.ds['time'] = xr.decode_cf(self.ds).time
+
+        self.ds = self.ds.sortby('time')  # Ensure sorted time axis
+        self.ds = self.ds.sel(time=slice(start, end))

ocstrack/Satellite/urls.py

@@ -0,0 +1,11 @@
+
+URL_TEMPLATES = {
+    'sentinel3a': 'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/3a/3a_',
+    'sentinel3b': 'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/3b/3b_',
+    'sentinel6a': 'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/6a/6a_',
+    'jason2':     'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/j2/j2_',
+    'jason3':     'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/j3/j3_',
+    'cryosat2':   'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/c2/c2_',
+    'saral':      'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/sa/sa_',
+    'swot':       'https://www.star.nesdis.noaa.gov/data/pub0010/lsa/johnk/coastwatch/sw/sw_',
+}

ocstrack/__init__.py

@@ -0,0 +1 @@
+

ocstrack/utils.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Union
+
+import numpy as np
+
+# Set up logging
+logging.basicConfig(
+    level=logging.WARNING,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+    ]
+)
+_logger = logging.getLogger()
+
+
+def convert_longitude(lon: Union[float, np.ndarray],
+                      mode: int = 1) -> np.ndarray:
+    """
+    Convert longitudes between common geographic conventions.
+
+    Args:
+        lon: array-like of longitudes
+        mode: conversion mode:
+            - 1: Convert from [-180, 180] (Greenwich at 0°) → [0, 360] (Greenwich at 0°)
+            - 2: Convert from [0, 360] (Greenwich at 0°) → [-180, 180] (Greenwich at 0°)
+            - 3: Convert from [-180, 180] (Greenwich at 0°) → [0, 360] (Greenwich at 180°)
+            - 4: Convert from [0, 360] (Greenwich at 0°) → [0, 360] (Greenwich at 180°)
+            - 5: Convert from [0, 360] (Greenwich at 180°) → [0, 360] (Greenwich at 0°)
+
+    Returns:
+        np.ndarray of converted longitudes
+    """
+    _logger.debug("Converting longitude with mode %d", mode)
+    lon = np.asarray(lon)
+    if mode == 1:
+        return lon % 360
+    elif mode == 2:
+        return np.where(lon > 180, lon - 360, lon)
+    elif mode == 3:
+        return lon + 180
+    elif mode == 4:
+        return (lon + 180) % 360
+    elif mode == 5:
+        return (lon - 180) % 360
+    else:
+        raise ValueError(f"Invalid mode {mode}. Supported modes: 1, 2, 3, 4, 5")

ocstrack-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: ocstrack
+Version: 0.1.0
+Summary: Satellite data download, crop, and collocation with model outputs
+Author-email: Felicio Cassalho <felicio.cassalho@noaa.gov>
+License: MIT
+Project-URL: Homepage, https://github.com/noaa-ocs-modeling/OCSTrack
+Project-URL: Repository, https://github.com/noaa-ocs-modeling/OCSTrack
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: xarray
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Requires-Dist: requests
+Requires-Dist: netcdf4
+Requires-Dist: h5netcdf
+Dynamic: license-file
+
+# OCSTrack
+OCSTrack is an object-oriented Python package for the along-track collocation of satellite data with ocean circulation and wave model outputs.
+It simplifies the process of aligning diverse datasets, making it easier to compare and analyze satellite observations against model simulations.
+
+## Key Features
+### Satellite Altimetry Data Support
+
+Seamlessly integrates with NOAA [CoastalWatch](https://coastwatch.noaa.gov/cwn/products/along-track-significant-wave-height-wind-speed-and-sea-level-anomaly-multiple-altimeters.html) altimetry data, providing access to a wide range of missions:
+ * Jason-2
+ * Jason-3
+ * Sentinel-3A
+ * Sentinel-3B
+ * Sentinel-6A
+ * CryoSat-2
+ * SARAL
+ * SWOT
+
+### Ocean Model Data Support
+ Supports outputs from various ocean circulation and wave models:
+ * [SCHISM+WWM](https://github.com/schism-dev/schism)
+ * WaveWatch3 (to be implemented)
+ * ADCIRC+SWAN (to be implemented)
+
+
+## Installation
+
+1.  **Create and activate a new conda environment:**
+    This command creates an environment named `ocstrack` and installs all dependencies from `conda-forge`.
+    ```bash
+    conda create -n ocstrack -c conda-forge python=3.10 numpy xarray scipy tqdm requests netcdf4 h5netcdf
+    conda activate ocstrack
+    ```
+
+2.  **Install `ocstrack` from GitHub:**
+    Finally, install this package using `pip`.
+    ```bash
+    pip install "git+[https://github.com/noaa-ocs-modeling/OCSTrack.git](https://github.com/noaa-ocs-modeling/OCSTrack.git)"
+    ```
+
+## Usage
+Here's a typical workflow demonstrating how to use OCSTrack to download satellite data, load model outputs, and perform collocation.
+```
+import numpy as np
+import xarray as xr
+# Assuming ocstrack is installed and available in your environment
+from ocstrack.Model.model import SCHISM
+from ocstrack.Satellite.satellite import SatelliteData
+from ocstrack.Satellite import get_sat
+from ocstrack.Collocation.collocate import Collocate
+from ocstrack.utils import convert_longitude
+
+
+# 1. Download Satellite Data
+#    Specify your desired date range, list of satellites, output directory, and geographical bounding box.
+get_sat.get_multi_sat(start_date="2019-07-30",
+                      end_date="2019-08-04",
+                      sat_list=['sentinel3a','sentinel3b','jason2','jason3','cryosat2','saral'],
+                      output_dir=r"Your/Path/Here/",
+                      lat_min=49.109,
+                      lat_max=66.304309,
+                      lon_min=156.6854,
+                      lon_max=-156.864,
+                     )
+
+# 2. Define File Paths
+#    Set the paths for your downloaded satellite data, model run, and where you want to save the collocated output.
+sat_path = "/path/to/your/multisat_cropped_2019-07-30_2019-08-04.nc"
+model_path = "/path/to/your/model/run/"
+output_path =  "/path/to/your/collocated_output.nc"
+s_time,e_time = "2019-08-01", "2019-08-03"
+
+# 3. Load Satellite Data
+#    Initialize the SatelliteData object with your satellite data file.
+sat_data = SatelliteData(sat_path)
+#    It's crucial to ensure longitude conventions match between satellite and model data.
+#    Use convert_longitude if needed (mode=1 for converting to 0-360 degrees).
+sat_data.lon = convert_longitude(sat_data.lon, mode=1)
+
+# 4. Load Model Data
+#    Instantiate the SCHISM model object, specifying the run directory and model variable details.
+model_run = SCHISM(
+                    rundir=model_path,
+                    model_dict={'var': 'sigWaveHeight',
+                                'startswith': 'out2d_', # File name prefix for 2D outputs
+                                'var_type': '2D',
+                                'model': 'SCHISM'},
+                    start_date=np.datetime64(s_time),
+                    end_date=np.datetime64(e_time)
+                  )
+
+# 5. Perform Collocation
+#    Create a Collocate object, providing the loaded model and satellite data.
+coll = Collocate(
+                 model_run=model_run,
+                 satellite=sat_data,
+                 # dist_coast=dist_coast,
+                 n_nearest=3,
+                 # search_radius = 3000,
+                 temporal_interp=True
+                 )
+ds_coll = coll.run(output_path=output_path) # Execute the collocation and save the results
+```
+
+## Contributing
+We welcome contributions to OCSTrack! If you have ideas for improvements, new features, or find a bug, please don't hesitate to open an issue or submit a pull request on our GitHub repository. Your input helps make OCSTrack better for everyone.
+
+### Contact
+<sub><sup>Contact: felicio.cassalho@noaa.gov </sup></sub>
+
+![NOAA logo](https://user-images.githubusercontent.com/72229285/216712553-c1e4b2fa-4b6d-4eab-be0f-f7075b6151d1.png)
+
+
+#### Acknowledgements:
+*OCSTrack was inspired by the MATLAB-based [WW3-tools](https://github.com/NOAA-EMC/WW3-tools) and [wave-tools](https://github.com/NOAA-EMC/WW3-tools) collocation tools developed for WaveWatch3.*

ocstrack-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+ocstrack/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+ocstrack/utils.py,sha256=js_J3m2CqHDpryNNRRWkROrqiY4PqC86hH7jHVXHy5s,1543
+ocstrack/Collocation/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+ocstrack/Collocation/collocate.py,sha256=B_niVPz_zB1cUXJcZyoIbxoH0TEOkOevjoogctAP1Y4,17648
+ocstrack/Collocation/output.py,sha256=NT1orNapFx7WCOkqouSiylL_Qz_BRCjPi1xIYB1SloI,2730
+ocstrack/Collocation/spatial.py,sha256=OH6m7QlkI-FnkegZsX6tkNXxvwXMRCDco41SyS12pGE,6657
+ocstrack/Collocation/temporal.py,sha256=BPjXJqxMiBFNSbLV2gGUSSl39HpZDIZiNByk1-j4eAs,4010
+ocstrack/Model/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+ocstrack/Model/model.py,sha256=vxkxYMbxFfiV_0T-JDqT2D2q3LZmpL_CFMH6vRLwhBM,7887
+ocstrack/Satellite/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+ocstrack/Satellite/get_sat.py,sha256=2Ut5K5ca_Pf_Pl9GUv-5Tg7OaujseQ2xG8_qsRfUCBA,12830
+ocstrack/Satellite/satellite.py,sha256=O0vcbRrotp3xaTpVdBct-OnEiI5zG2evSB8siEIIxY8,3135
+ocstrack/Satellite/urls.py,sha256=Q1MSanZwTnsjghRO6j9yH8ZGWVo6Y0EWraxOCN4dR6E,790
+ocstrack-0.1.0.dist-info/licenses/LICENSE.txt,sha256=9Ofzc7m5lpUDN-jUGkopOcLZC3cl6brz1QhKInF60yg,7169
+ocstrack-0.1.0.dist-info/METADATA,sha256=Zfp3T6kMOPg1Na7RwHDJ34MCJ-j34L0nWUqBGCyndy4,5657
+ocstrack-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ocstrack-0.1.0.dist-info/top_level.txt,sha256=II1d5yXek4m6ld-nK6MGUXQT8dpvgrgPRJuYgyIfJhA,9
+ocstrack-0.1.0.dist-info/RECORD,,

ocstrack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+