IW search works

Author: nic-planet

src/planet/backends.py

@@ -28,7 +28,7 @@
 from stapi_fastapi.routers.product_router import ProductRouter
 
 from client import Client
-from conversions import planet_order_to_stapi_order, stapi_opportunity_payload_to_planet_iw_search
+import conversions
 
 
 async def mock_get_orders(
@@ -64,7 +64,7 @@ async def get_order(order_id: str, request: Request) -> ResultE[Maybe[Order]]:
     """
     try:
         return Success(
-            Maybe.from_optional(planet_order_to_stapi_order(Client(request).get_order(order_id)))
+            Maybe.from_optional(conversions.planet_order_to_stapi_order(Client(request).get_order(order_id)))
         )
     except Exception as e:
         return Failure(e)
@@ -140,11 +140,11 @@ async def search_opportunities(
     request: Request,
 ) -> ResultE[tuple[list[Opportunity], Maybe[str]]]:
     try:
-        iw_request = stapi_opportunity_payload_to_planet_iw_search(product_router.product, search)
+        iw_request = conversions.stapi_opportunity_payload_to_planet_iw_search(product_router.product, search)
         imaging_windows = Client(request).get_imaging_windows(iw_request)
 
         opportunities = [
-            imaging_window_to_opportunity(iw, search)
+            conversions.planet_iw_to_stapi_opportunity(iw, product_router.product, search)
             for iw
             in imaging_windows
         ]

src/planet/client.py

@@ -38,9 +38,10 @@ def get_imaging_windows(self, payload: dict) -> dict:
                 "Header 'location' not found: %s, status %s, body %s" % (
                     list(r.headers.keys()), r.status_code, r.text)
             )
-        poll_url = r.headers['location']
+        poll_url = f"{Settings().api_domain}{r.headers['location']}"
 
         while True:
+            print('polling', poll_url)
             r = requests.get(poll_url, headers=self.headers)
             r.raise_for_status()
             status = r.json()['status']

src/planet/conversions.py

@@ -2,6 +2,7 @@
 
 from pydantic import AwareDatetime
 
+from planet.models import PlanetOpportunityProperties, OffNadirAngleRange, PlanetSatelliteType
 from stapi_fastapi import Product
 from stapi_fastapi.models.order import Order, OrderProperties, OrderSearchParameters, OrderStatus, OrderStatusCode
 from stapi_fastapi.models.opportunity import (
@@ -82,16 +83,25 @@ def stapi_opportunity_payload_to_planet_iw_search(product: Product, search: Oppo
         "geometry": search.geometry.dict(),
     }
 
-def planet_iw_to_stapi_opportunity(iw: dict, search: OpportunityPayload) -> Opportunity:
+def planet_iw_to_stapi_opportunity(iw: dict, product: Product, search: OpportunityPayload) -> Opportunity:
+
+    print(iw)
+
+    properties = PlanetOpportunityProperties(
+        product_id=product.id,
+        datetime=(iw['start_time'], iw['end_time']),
+        off_nadir_angle=OffNadirAngleRange(
+            minimum=iw['off_nadir_angle_min'],
+            maximum=iw['off_nadir_angle_max']),
+        satellite_type=PlanetSatelliteType(iw['satellite_type']),
+        title='Planet Assured Imaging Window @ ' + iw['start_time'],
+    )
+    if 'cloud_forecast' in iw and len(cf := iw['cloud_forecast']) > 0:
+        properties.cloud_forecast = cf[0].get('prediction')
+
     return Opportunity(
         id=iw["id"],
+        type="Feature",
         geometry=search.geometry,
-        properties={
-            'title': 'Planet Assured Imaging Window @ ' + iw['start_time'],
-            'datetime': f"{iw['start_time']}/{iw['end_time']}",
-            'product_id': search.product_id,
-            'constraints': {
-                'off_nadir': [iw['start_off_nadir'], iw['end_off_nadir']],
-                'cloud_cover': iw['cloud_forecast'][0]['prediction']
-            }
-        })
+        properties=properties
+    )

src/planet/models.py

@@ -0,0 +1,72 @@
+from typing import Any, Literal, Self
+from enum import Enum
+
+
+from pydantic import BaseModel, Field, model_validator
+
+from stapi_fastapi.models.opportunity import (
+    Opportunity,
+    OpportunityCollection,
+    OpportunityProperties,
+    OpportunitySearchRecord,
+)
+from stapi_fastapi.models.order import (
+    Order,
+    OrderParameters,
+    OrderStatus,
+)
+from stapi_fastapi.models.product import (
+    Product,
+    Provider,
+    ProviderRole,
+)
+
+class PlanetSatelliteType(str, Enum):
+    SKYSAT = 'SKYSAT'
+    PELICAN = 'PELICAN'
+    TANAGER = 'TANAGER'
+
+class PlanetProductConstraints(BaseModel):
+    off_nadir: float
+
+
+class OffNadirAngleRange(BaseModel):
+    minimum: float = Field(ge=0, le=90)
+    maximum: float = Field(ge=0, le=90)
+
+    @model_validator(mode="after")
+    def validate_range(self) -> Self:
+        if self.minimum > self.maximum:
+            raise ValueError("range minimum cannot be greater than maximum")
+        return self
+
+
+class PlanetOpportunityProperties(OpportunityProperties):
+    off_nadir_angle: OffNadirAngleRange
+    satellite_type: PlanetSatelliteType
+    # off_nadir start/end
+    # sat_elevation_angle
+    # sat_azimuth_angle
+    # sat_azimuth_angle start/end
+    # sun_elevation_angle
+    # solar_zenith_angle
+    # low_light
+    # ground_sample_distance
+    # assured_tasking_tier
+    # conflicting_orders
+    # quota_priority_multiplier
+    # cloud_forecast
+    # sensitivity_mode
+
+
+class PlanetOrderParameters(OrderParameters):
+    s3_path: str | None = None
+
+
+
+provider_planet = Provider(
+    name="Planet",
+    description="A provider for Test data",
+    roles=[ProviderRole.producer],  # Example role
+    url="https://www.planet.com",  # Must be a valid URL
+)

src/planet/settings.py

@@ -4,8 +4,6 @@
 from pydantic_settings import BaseSettings
 
 API_DOMAIN = "https://api.planet.com"
-API_BASE_URL = "https://api.staging.planet-labs.com"
-API_BASE_URL = "https://api.planet.com"
 
 
 class LogLevel(Enum):

src/planet/shared.py

@@ -30,6 +30,13 @@
     ProviderRole,
 )
 
+from models import (
+    PlanetProductConstraints,
+    PlanetOpportunityProperties,
+    PlanetOrderParameters,
+    provider_planet
+)
+
 from backends import (
     mock_create_order,
     mock_get_opportunity_collection,
@@ -90,38 +97,9 @@ def put_opportunity_collection(self, collection: OpportunityCollection) -> None:
 
 
 
-class MyProductConstraints(BaseModel):
-    off_nadir: int
-
-
-class OffNadirRange(BaseModel):
-    minimum: int = Field(ge=0, le=45)
-    maximum: int = Field(ge=0, le=45)
-
-    @model_validator(mode="after")
-    def validate_range(self) -> Self:
-        if self.minimum > self.maximum:
-            raise ValueError("range minimum cannot be greater than maximum")
-        return self
-
 
-class MyOpportunityProperties(OpportunityProperties):
-    off_nadir: OffNadirRange
-    vehicle_id: list[Literal[1, 2, 5, 7, 8]]
-    platform: Literal["platform_id"]
 
 
-class MyOrderParameters(OrderParameters):
-    s3_path: str | None = None
-
-
-provider_planet = Provider(
-    name="Planet",
-    description="A provider for Test data",
-    roles=[ProviderRole.producer],  # Example role
-    url="https://www.planet.com",  # Must be a valid URL
-)
-
 
 product_test_planet_sync_opportunity = Product(
     id="INT-003001:Assured Tasking",
@@ -135,31 +113,8 @@ class MyOrderParameters(OrderParameters):
     search_opportunities=search_opportunities,
     search_opportunities_async=None,
     get_opportunity_collection=None,
-    constraints=MyProductConstraints,
-    opportunity_properties=MyOpportunityProperties,
-    order_parameters=MyOrderParameters,
+    constraints=PlanetProductConstraints,
+    opportunity_properties=PlanetOpportunityProperties,
+    order_parameters=PlanetOrderParameters,
 )
 
-
-def create_mock_opportunity() -> Opportunity:
-    now = datetime.now(timezone.utc)  # Use timezone-aware datetime
-    start = now
-    end = start + timedelta(days=5)
-
-    # Create a list of mock opportunities for the given product
-    return Opportunity(
-        id=str(uuid4()),
-        type="Feature",
-        geometry=Point(
-            type="Point",
-            coordinates=Position2D(longitude=0.0, latitude=0.0),
-        ),
-        properties=MyOpportunityProperties(
-            product_id="xyz123",
-            datetime=(start, end),
-            off_nadir=OffNadirRange(minimum=20, maximum=22),
-            vehicle_id=[1],
-            platform="platform_id",
-            other_thing="abcd1234",  # type: ignore
-        ),
-    )