apply mappings, fix type problem with transactions methods

Author: Phil Varner

Dockerfile

@@ -14,10 +14,9 @@ ARG install_dev_dependencies=true
 
 WORKDIR /app
 
-# Install stac_fastapi.types
 COPY . /app
 
 ENV PATH=$PATH:/install/bin
 
-RUN mkdir -p /install && \
-    pip install --no-cache-dir -e ./stac_fastapi/elasticsearch[dev,server]
+RUN mkdir -p /install
+RUN pip install --no-cache-dir -e ./stac_fastapi/elasticsearch[dev,server]

README.md

@@ -10,7 +10,7 @@ Install [pre-commit](https://pre-commit.com/#install).
 
 Prior to commit, run:
 
-```
+```shell
 pre-commit run --all-files`
 ```
 
@@ -21,25 +21,25 @@ pip install .[dev]
 
 ## Building
 
-```
+```shell
 docker-compose build
 ```
 
 ## Running API on localhost:8083
 
-```
+```shell
 docker-compose up
 ```
 
 ## Testing
 
-```
+```shell
 make test
 ```
 
 ## Ingest sample data
 
-```
+```shell
 make ingest
 ```
 

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/core.py

@@ -227,7 +227,8 @@ def get_search(
 
         return resp
 
-    def bbox2poly(self, b0, b1, b2, b3):
+    @staticmethod
+    def bbox2poly(b0, b1, b2, b3):
         """Transform bbox to polygon."""
         poly = [[[b0, b1], [b2, b1], [b2, b3], [b0, b3], [b0, b1]]]
         return poly

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/transactions.py

@@ -2,6 +2,7 @@
 
 import logging
 from datetime import datetime, timezone
+from typing import Optional
 
 import attr
 import elasticsearch
@@ -104,108 +105,118 @@ class TransactionsClient(BaseTransactionsClient):
         },
     }
 
-    def _create_item_index(self):
+    def create_item_index(self):
+        """Create the index for Items."""
         self.client.indices.create(
             index="stac_items",
-            body=self.mappings,
+            body={"mappings": self.mappings},
             ignore=400,  # ignore 400 already exists code
         )
 
     @overrides
-    def create_item(self, model: stac_types.Item, **kwargs):
+    def create_item(self, item: stac_types.Item, **kwargs) -> stac_types.Item:
         """Create item."""
         base_url = str(kwargs["request"].base_url)
-        self._create_item_index()
+        self.create_item_index()
 
         # If a feature collection is posted
-        if model["type"] == "FeatureCollection":
+        if item["type"] == "FeatureCollection":
             bulk_client = BulkTransactionsClient()
             processed_items = [
                 bulk_client._preprocess_item(item, base_url)
-                for item in model["features"]
+                for item in item["features"]
             ]
             return_msg = f"Successfully added {len(processed_items)} items."
             bulk_client.bulk_sync(processed_items)
 
             return return_msg
 
         # If a single item is posted
-        if not self.client.exists(index="stac_collections", id=model["collection"]):
-            raise ForeignKeyError(f"Collection {model['collection']} does not exist")
+        if not self.client.exists(index="stac_collections", id=item["collection"]):
+            raise ForeignKeyError(f"Collection {item['collection']} does not exist")
 
-        if self.client.exists(index="stac_items", id=model["id"]):
+        if self.client.exists(index="stac_items", id=item["id"]):
             raise ConflictError(
-                f"Item {model['id']} in collection {model['collection']} already exists"
+                f"Item {item['id']} in collection {item['collection']} already exists"
             )
 
-        data = ItemSerializer.stac_to_db(model, base_url)
+        data = ItemSerializer.stac_to_db(item, base_url)
 
         self.client.index(
-            index="stac_items", doc_type="_doc", id=model["id"], document=data
+            index="stac_items", doc_type="_doc", id=item["id"], document=data
         )
-        return ItemSerializer.db_to_stac(model, base_url)
+        return ItemSerializer.db_to_stac(item, base_url)
 
     @overrides
-    def create_collection(self, model: stac_types.Collection, **kwargs):
-        """Create collection."""
-        base_url = str(kwargs["request"].base_url)
-        collection_links = CollectionLinks(
-            collection_id=model["id"], base_url=base_url
-        ).create_links()
-        model["links"] = collection_links
-
-        self._create_item_index()
-
-        if self.client.exists(index="stac_collections", id=model["id"]):
-            raise ConflictError(f"Collection {model['id']} already exists")
-        self.client.index(
-            index="stac_collections", doc_type="_doc", id=model["id"], document=model
-        )
-        return CollectionSerializer.db_to_stac(model, base_url)
-
-    @overrides
-    def update_item(self, model: stac_types.Item, **kwargs):
+    def update_item(self, item: stac_types.Item, **kwargs) -> stac_types.Item:
         """Update item."""
         base_url = str(kwargs["request"].base_url)
         now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-        model["properties"]["updated"] = str(now)
+        item["properties"]["updated"] = str(now)
 
-        if not self.client.exists(index="stac_collections", id=model["collection"]):
-            raise ForeignKeyError(f"Collection {model['collection']} does not exist")
-        if not self.client.exists(index="stac_items", id=model["id"]):
+        if not self.client.exists(index="stac_collections", id=item["collection"]):
+            raise ForeignKeyError(f"Collection {item['collection']} does not exist")
+        if not self.client.exists(index="stac_items", id=item["id"]):
             raise NotFoundError(
-                f"Item {model['id']} in collection {model['collection']} doesn't exist"
+                f"Item {item['id']} in collection {item['collection']} doesn't exist"
             )
-        self.delete_item(model["id"], model["collection"])
-        self.create_item(model, **kwargs)
+        self.delete_item(item["id"], item["collection"])
+        self.create_item(item, **kwargs)
         # self.client.update(index="stac_items",doc_type='_doc',id=model["id"],
         #         body=model)
-        return ItemSerializer.db_to_stac(model, base_url)
+        return ItemSerializer.db_to_stac(item, base_url)
 
     @overrides
-    def update_collection(self, model: stac_types.Collection, **kwargs):
-        """Update collection."""
-        base_url = str(kwargs["request"].base_url)
+    def delete_item(
+        self, item_id: str, collection_id: str, **kwargs
+    ) -> stac_types.Item:
+        """Delete item."""
         try:
-            _ = self.client.get(index="stac_collections", id=model["id"])
+            _ = self.client.get(index="stac_items", id=item_id)
         except elasticsearch.exceptions.NotFoundError:
-            raise NotFoundError(f"Collection {model['id']} not found")
-        self.delete_collection(model["id"])
-        self.create_collection(model, **kwargs)
+            raise NotFoundError(f"Item {item_id} not found")
+        self.client.delete(index="stac_items", doc_type="_doc", id=item_id)
+
+    @overrides
+    def create_collection(
+        self, collection: stac_types.Collection, **kwargs
+    ) -> stac_types.Collection:
+        """Create collection."""
+        base_url = str(kwargs["request"].base_url)
+        collection_links = CollectionLinks(
+            collection_id=collection["id"], base_url=base_url
+        ).create_links()
+        collection["links"] = collection_links
 
-        return CollectionSerializer.db_to_stac(model, base_url)
+        self.create_item_index()
+
+        if self.client.exists(index="stac_collections", id=collection["id"]):
+            raise ConflictError(f"Collection {collection['id']} already exists")
+        self.client.index(
+            index="stac_collections",
+            doc_type="_doc",
+            id=collection["id"],
+            document=collection,
+        )
+        return CollectionSerializer.db_to_stac(collection, base_url)
 
     @overrides
-    def delete_item(self, item_id: str, collection_id: str, **kwargs):
-        """Delete item."""
+    def update_collection(
+        self, collection: stac_types.Collection, **kwargs
+    ) -> stac_types.Collection:
+        """Update collection."""
+        base_url = str(kwargs["request"].base_url)
         try:
-            _ = self.client.get(index="stac_items", id=item_id)
+            _ = self.client.get(index="stac_collections", id=collection["id"])
         except elasticsearch.exceptions.NotFoundError:
-            raise NotFoundError(f"Item {item_id} not found")
-        self.client.delete(index="stac_items", doc_type="_doc", id=item_id)
+            raise NotFoundError(f"Collection {collection['id']} not found")
+        self.delete_collection(collection["id"])
+        self.create_collection(collection, **kwargs)
+
+        return CollectionSerializer.db_to_stac(collection, base_url)
 
     @overrides
-    def delete_collection(self, collection_id: str, **kwargs):
+    def delete_collection(self, collection_id: str, **kwargs) -> stac_types.Collection:
         """Delete collection."""
         try:
             _ = self.client.get(index="stac_collections", id=collection_id)
@@ -246,10 +257,12 @@ def bulk_sync(self, processed_items):
         helpers.bulk(self.client, actions)
 
     @overrides
-    def bulk_item_insert(self, items: Items, **kwargs) -> str:
+    def bulk_item_insert(
+        self, items: Items, chunk_size: Optional[int] = None, **kwargs
+    ) -> str:
         """Bulk item insertion using es."""
         transactions_client = TransactionsClient()
-        transactions_client._create_item_index()
+        transactions_client.create_item_index()
         try:
             base_url = str(kwargs["request"].base_url)
         except Exception: