rs-client-libraries 0.2a10__tar.gz → 0.2a11__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (20) hide show
  1. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/PKG-INFO +1 -1
  2. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/pyproject.toml +1 -1
  3. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/rs_client/__init__.py +1 -1
  4. rs_client_libraries-0.2a11/rs_client/auxip_client.py +79 -0
  5. rs_client_libraries-0.2a11/rs_client/cadip_client.py +67 -0
  6. rs_client_libraries-0.2a10/rs_client/stac_client.py → rs_client_libraries-0.2a11/rs_client/catalog_client.py +108 -183
  7. rs_client_libraries-0.2a11/rs_client/rs_client.py +300 -0
  8. rs_client_libraries-0.2a11/rs_client/stac_base.py +312 -0
  9. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/rs_client/staging_client.py +11 -14
  10. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/rs_common/config.py +7 -0
  11. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/rs_common/utils.py +10 -0
  12. rs_client_libraries-0.2a10/rs_client/auxip_client.py +0 -61
  13. rs_client_libraries-0.2a10/rs_client/cadip_client.py +0 -142
  14. rs_client_libraries-0.2a10/rs_client/rs_client.py +0 -439
  15. rs_client_libraries-0.2a10/rs_common/serialization.py +0 -86
  16. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/LICENSE +0 -0
  17. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/README.adoc +0 -0
  18. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/rs_common/__init__.py +0 -0
  19. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/rs_common/logging.py +0 -0
  20. {rs_client_libraries-0.2a10 → rs_client_libraries-0.2a11}/rs_common/opentelemetry.py +0 -0
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.1
2
2
  Name: rs-client-libraries
3
- Version: 0.2a10
3
+ Version: 0.2a11
4
4
  Summary: Copernicus Sentinel rs-client library and processing workflows.
5
5
  Home-page: https://home.rs-python.eu/
6
6
  License: Apache-2.0
@@ -4,7 +4,7 @@ version = "0.0.0" # see: https://github.com/mtkennerly/poetry-dynamic-versioning
4
4
 
5
5
  [tool.poetry]
6
6
  name = "rs-client-libraries"
7
- version = "0.2a10"
7
+ version = "0.2a11"
8
8
  description = "Copernicus Sentinel rs-client library and processing workflows."
9
9
  license = "Apache-2.0"
10
10
  authors = ["ESA under contract with Airbus and CS <ops_coprs@airbus.com>"]
@@ -15,4 +15,4 @@
15
15
  """rsclient main module."""
16
16
 
17
17
  # Set automatically by running `poetry dynamic-versioning`
18
- __version__ = "0.2a10"
18
+ __version__ = "0.2a11"
@@ -0,0 +1,79 @@
1
+ # Copyright 2024 CS Group
2
+ #
3
+ # Licensed under the Apache License, Version 2.0 (the "License");
4
+ # you may not use this file except in compliance with the License.
5
+ # You may obtain a copy of the License at
6
+ #
7
+ # http://www.apache.org/licenses/LICENSE-2.0
8
+ #
9
+ # Unless required by applicable law or agreed to in writing, software
10
+ # distributed under the License is distributed on an "AS IS" BASIS,
11
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
+ # See the License for the specific language governing permissions and
13
+ # limitations under the License.
14
+
15
+ """AuxipClient class implementation."""
16
+
17
+ import logging
18
+
19
+ from rs_client.stac_base import StacBase
20
+ from rs_common.config import EAuxipStation
21
+ from rs_common.utils import get_href_service
22
+
23
+
24
+ class AuxipClient(StacBase):
25
+ """
26
+ AuxipClient class implementation.
27
+
28
+ Attributes: see :py:class:`RsClient`
29
+ """
30
+
31
+ def __init__( # pylint: disable=too-many-arguments, too-many-positional-arguments
32
+ self,
33
+ rs_server_href: str | None,
34
+ rs_server_api_key: str | None,
35
+ owner_id: str | None,
36
+ station: EAuxipStation | str,
37
+ logger: logging.Logger | None = None,
38
+ **kwargs,
39
+ ):
40
+ """
41
+ Initializes an AuxipClient instance.
42
+
43
+ Args:
44
+ rs_server_href (str | None): The URL of the RS-Server. Pass None for local mode.
45
+ rs_server_api_key (str | None): API key for authentication.
46
+ owner_id (str | None): ID of the catalog owner.
47
+ station (EAuxipStation | str): The AUXIP station identifier.
48
+ logger (logging.Logger | None, optional): Logger instance (default: None).
49
+ **kwargs: Additional keyword arguments.
50
+
51
+ Raises:
52
+ RuntimeError: If the provided station is not a valid AUXIP station.
53
+ """
54
+ super().__init__(
55
+ rs_server_href,
56
+ rs_server_api_key,
57
+ owner_id,
58
+ logger,
59
+ get_href_service(rs_server_href, "RSPY_HOST_ADGS") + "/auxip/",
60
+ **kwargs,
61
+ )
62
+ try:
63
+ self.station: EAuxipStation = EAuxipStation[station] if isinstance(station, str) else station
64
+ except KeyError as e:
65
+ self.log_and_raise(f"There is no such AUXIP station: {station}", e)
66
+
67
+ @property
68
+ def href_service(self) -> str:
69
+ """
70
+ Return the RS-Server ADGS URL hostname.
71
+ This URL can be overwritten using the RSPY_HOST_ADGS env variable (used e.g. for local mode).
72
+ Otherwise it should just be the RS-Server URL.
73
+ """
74
+ return get_href_service(self.rs_server_href, "RSPY_HOST_ADGS") + "/auxip"
75
+
76
+ @property
77
+ def station_name(self) -> str:
78
+ """Return the station name."""
79
+ return self.station.value
@@ -0,0 +1,67 @@
1
+ # Copyright 2024 CS Group
2
+ #
3
+ # Licensed under the Apache License, Version 2.0 (the "License");
4
+ # you may not use this file except in compliance with the License.
5
+ # You may obtain a copy of the License at
6
+ #
7
+ # http://www.apache.org/licenses/LICENSE-2.0
8
+ #
9
+ # Unless required by applicable law or agreed to in writing, software
10
+ # distributed under the License is distributed on an "AS IS" BASIS,
11
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
+ # See the License for the specific language governing permissions and
13
+ # limitations under the License.
14
+
15
+ """CadipClient class implementation."""
16
+
17
+ import logging
18
+
19
+ from rs_client.stac_base import StacBase
20
+ from rs_common.config import ECadipStation
21
+ from rs_common.utils import get_href_service
22
+
23
+
24
+ class CadipClient(StacBase):
25
+ """
26
+ CadipClient class implementation.
27
+
28
+ Attributes: see :py:class:`RsClient`
29
+ station (ECadipStation): Cadip station
30
+ """
31
+
32
+ def __init__( # pylint: disable=too-many-arguments, too-many-positional-arguments
33
+ self,
34
+ rs_server_href: str | None,
35
+ rs_server_api_key: str | None,
36
+ owner_id: str | None,
37
+ station: str,
38
+ logger: logging.Logger | None = None,
39
+ **kwargs,
40
+ ):
41
+ """CadipClient class constructor."""
42
+ super().__init__(
43
+ rs_server_href,
44
+ rs_server_api_key,
45
+ owner_id,
46
+ logger,
47
+ get_href_service(rs_server_href, "RSPY_HOST_CADIP") + "/cadip/",
48
+ **kwargs,
49
+ )
50
+ try:
51
+ self.station: ECadipStation = ECadipStation[station] if isinstance(station, str) else station
52
+ except KeyError as e:
53
+ self.log_and_raise(f"There is no such CADIP station: {station}", e)
54
+
55
+ @property
56
+ def href_service(self) -> str:
57
+ """
58
+ Return the RS-Server CADIP URL hostname.
59
+ This URL can be overwritten using the RSPY_HOST_CADIP env variable (used e.g. for local mode).
60
+ Otherwise it should just be the RS-Server URL.
61
+ """
62
+ return get_href_service(self.rs_server_href, "RSPY_HOST_CADIP") + "/cadip"
63
+
64
+ @property
65
+ def station_name(self) -> str:
66
+ """Return the station name."""
67
+ return self.station.value
@@ -12,39 +12,26 @@
12
12
  # See the License for the specific language governing permissions and
13
13
  # limitations under the License.
14
14
 
15
- """Implement the class StacCLient that inherits from pystact_client Client."""
15
+ """Implement the class CatalogClient that inherits from pystact_client Client."""
16
16
 
17
17
  from __future__ import annotations
18
18
 
19
19
  import logging
20
- import os
21
- from functools import lru_cache
22
- from typing import Any, Callable, Dict, List, Optional, Union
20
+ from typing import Iterator, Union
23
21
 
24
22
  import pystac
25
- from pystac import CatalogType, Collection, Item, Link, RelType
26
- from pystac.layout import HrefLayoutStrategy
27
- from pystac_client import Client, Modifiable
23
+ from pystac import Collection, Item, Link, RelType
28
24
  from pystac_client.collection_client import CollectionClient
29
- from pystac_client.item_search import (
30
- BBoxLike,
31
- DatetimeLike,
32
- FieldsLike,
33
- FilterLike,
34
- IDsLike,
35
- IntersectsLike,
36
- ItemSearch,
37
- QueryLike,
38
- SortbyLike,
39
- )
40
- from pystac_client.stac_api_io import StacApiIO, Timeout
41
- from requests import Request, Response
42
-
43
- from rs_client.rs_client import APIKEY_HEADER, TIMEOUT, RsClient
44
-
45
-
46
- class StacClient(RsClient, Client): # type: ignore # pylint: disable=too-many-ancestors
47
- """StacClient inherits from both rs_client.RsClient and pystac_client.Client. The goal of this class is to
25
+ from pystac_client.item_search import ItemSearch
26
+ from requests import Response
27
+
28
+ from rs_client.rs_client import TIMEOUT
29
+ from rs_client.stac_base import StacBase
30
+ from rs_common.utils import get_href_service
31
+
32
+
33
+ class CatalogClient(StacBase): # type: ignore # pylint: disable=too-many-ancestors
34
+ """CatalogClient inherits from both rs_client.RsClient and pystac_client.Client. The goal of this class is to
48
35
  allow an user to use RS-Server services more easily than calling REST endpoints directly.
49
36
  """
50
37
 
@@ -52,141 +39,113 @@ class StacClient(RsClient, Client): # type: ignore # pylint: disable=too-many-a
52
39
  # Initialisation #
53
40
  ##################
54
41
 
55
- # NOTE: super-init is called in .open(...)
56
- def __init__( # pylint: disable=too-many-arguments, too-many-positional-arguments, super-init-not-called
42
+ def __init__( # pylint: disable=too-many-arguments, too-many-positional-arguments
57
43
  self,
58
- id: str, # pylint: disable=redefined-builtin
59
- description: str,
60
- title: Optional[str] = None,
61
- stac_extensions: Optional[List[str]] = None,
62
- extra_fields: Optional[Dict[str, Any]] = None,
63
- href: Optional[str] = None,
64
- catalog_type: CatalogType = CatalogType.ABSOLUTE_PUBLISHED,
65
- strategy: Optional[HrefLayoutStrategy] = None,
66
- *,
67
- modifier: Optional[Callable[[Modifiable], None]] = None,
68
- **kwargs: Dict[str, Any],
69
- ):
70
- """
71
- Constructor. Called only by pystac.
72
- As an user: don't use this directly, call the open(...) class method instead or RsClient.get_stac_client(...).
73
- """
74
-
75
- # Call manually the parent pystac Client constructor.
76
- # The RsClient constructor will be called manually later.
77
- Client.__init__(
78
- self,
79
- id=id,
80
- description=description,
81
- title=title,
82
- stac_extensions=stac_extensions,
83
- extra_fields=extra_fields,
84
- href=href,
85
- catalog_type=catalog_type,
86
- strategy=strategy,
87
- modifier=modifier,
88
- **kwargs,
89
- )
90
-
91
- @classmethod
92
- def open( # type: ignore # pylint: disable=arguments-renamed, too-many-arguments, too-many-positional-arguments
93
- cls,
94
- # RsClient parameters
95
44
  rs_server_href: str | None,
96
45
  rs_server_api_key: str | None,
97
- rs_server_oauth2_cookie: str | None,
98
46
  owner_id: str | None,
99
47
  logger: logging.Logger | None = None,
100
- # pystac Client parameters
101
- headers: Optional[Dict[str, str]] = None,
102
- parameters: Optional[Dict[str, Any]] = None,
103
- ignore_conformance: Optional[bool] = None,
104
- modifier: Optional[Callable[[Modifiable], None]] = None,
105
- request_modifier: Optional[Callable[[Request], Union[Request, None]]] = None,
106
- stac_io: Optional[StacApiIO] = None,
107
- timeout: Optional[Timeout] = TIMEOUT,
108
- ) -> StacClient:
109
- """Create a new StacClient instance."""
110
-
111
- # Save the API key in the HTTP headers
112
- if rs_server_api_key:
113
- if headers is None:
114
- headers = {}
115
- headers[APIKEY_HEADER] = rs_server_api_key
116
-
117
- # Save the OAuth2 authentication cookie in the pystac client cookies
118
- if rs_server_oauth2_cookie:
119
- if stac_io is None:
120
- stac_io = StacApiIO( # This is what is done in pystac_client/client.py::from_file
121
- headers=headers,
122
- parameters=parameters,
123
- request_modifier=request_modifier,
124
- timeout=timeout,
125
- )
126
- stac_io.session.cookies.set("session", rs_server_oauth2_cookie)
127
-
128
- client: StacClient = super().open( # type: ignore
129
- cls.__href_catalog(rs_server_href) + "/catalog/",
130
- headers,
131
- parameters,
132
- ignore_conformance,
133
- modifier,
134
- request_modifier,
135
- stac_io,
136
- timeout,
137
- )
138
-
139
- # Manual call to the parent RsClient constructor
140
- RsClient.__init__(
141
- client,
142
- rs_server_href=rs_server_href,
143
- rs_server_api_key=rs_server_api_key,
144
- owner_id=owner_id,
145
- logger=logger,
48
+ **kwargs,
49
+ ):
50
+ """CatalogClient class constructor."""
51
+ super().__init__(
52
+ rs_server_href,
53
+ rs_server_api_key,
54
+ owner_id,
55
+ logger,
56
+ get_href_service(rs_server_href, "RSPY_HOST_CATALOG") + "/catalog/",
57
+ **kwargs,
146
58
  )
147
59
 
148
- return client
149
-
150
60
  ##############
151
61
  # Properties #
152
62
  ##############
153
-
154
63
  @property
155
- def href_catalog(self) -> str:
64
+ def href_service(self) -> str:
156
65
  """
157
- Return the RS-Server catalog URL hostname.
66
+ Return the RS-Server Catalog URL hostname.
158
67
  This URL can be overwritten using the RSPY_HOST_CATALOG env variable (used e.g. for local mode).
159
68
  Otherwise it should just be the RS-Server URL.
160
69
  """
161
- return self.__href_catalog(self.rs_server_href)
162
70
 
163
- @staticmethod
164
- def __href_catalog(rs_server_href) -> str:
165
- if from_env := os.getenv("RSPY_HOST_CATALOG", None):
166
- return from_env.rstrip("/")
167
- if not rs_server_href:
168
- raise RuntimeError("RS-Server URL is undefined")
169
- return rs_server_href.rstrip("/")
71
+ return get_href_service(self.rs_server_href, "RSPY_HOST_CATALOG")
170
72
 
171
- def full_collection_id(self, owner_id: str | None, collection_id: str):
73
+ def full_collection_id(self, owner_id: str | None, collection_id: str, concat_char: str | None = None):
172
74
  """
173
- Return the full collection name as: <owner_id>:<collection_id>
75
+ Generates a full collection identifier by concatenating the owner ID and collection ID.
174
76
 
175
- Args:
176
- owner_id (str): Collection owner ID. If missing, we use self.owner_id.
177
- collection_id (str): Collection name
77
+ This function constructs a full collection ID by combining the provided `owner_id` (or a
78
+ default owner ID from `self.owner_id`) with `collection_id` using a specified separator.
79
+
80
+ Parameters:
81
+ owner_id (str | None): The owner identifier. If `None`, it defaults to `self.owner_id`.
82
+ collection_id (str): The collection identifier that must always be provided.
83
+ concat_char (str | None, optional): The character used to concatenate `owner_id`
84
+ and `collection_id`. Defaults to ":".
85
+
86
+ Returns:
87
+ str: A string representing the full collection ID, formatted as:
88
+ `"owner_id:collection_id"` by default or using the specified `concat_char`, that may
89
+ be `_`.
90
+
91
+ Raises:
92
+ - **AttributeError**: If `self.owner_id` is not set and `owner_id` is `None`,
93
+ causing an attempt to concatenate a `NoneType` with a string.
94
+
95
+ Notes:
96
+ - This function is useful in scenarios where collections are stored with unique
97
+ identifiers that require owner prefixes for proper scoping.
178
98
  """
179
- return f"{owner_id or self.owner_id}:{collection_id}"
99
+
100
+ if not concat_char:
101
+ concat_char = ":"
102
+ return f"{owner_id or self.owner_id}{concat_char}{collection_id}"
180
103
 
181
104
  ################################
182
105
  # Specific STAC implementation #
183
106
  ################################
184
107
 
185
- @lru_cache()
186
- def get_collection(self, collection_id: str, owner_id: str | None = None) -> Union[Collection, CollectionClient]:
187
- """Get the requested collection as <owner_id>:<collection_id>"""
188
- full_collection_id = self.full_collection_id(owner_id, collection_id)
189
- return Client.get_collection(self, full_collection_id)
108
+ # STAC read opperations. These can be done with pystac_client (by calling super StacBase functions)
109
+
110
+ def get_collection( # type: ignore
111
+ self,
112
+ collection_id: str,
113
+ owner_id: str | None = None,
114
+ ) -> Union[Collection, CollectionClient]:
115
+ """Get the requested collection"""
116
+ return super().get_collection(self.full_collection_id(owner_id, collection_id, ":"))
117
+
118
+ def get_items(
119
+ self,
120
+ collection_id: str,
121
+ items_ids: Union[str, None] = None,
122
+ owner_id: str | None = None,
123
+ ) -> Iterator["Item"]:
124
+ """Get all items from a specific collection."""
125
+ return super().get_items(self.full_collection_id(owner_id, collection_id, ":"), items_ids)
126
+
127
+ def get_item(self, collection_id: str, item_id: str, owner_id: str | None = None):
128
+ """Get an item from a specific collection."""
129
+ return super().get_item(self.full_collection_id(owner_id, collection_id, ":"), item_id)
130
+
131
+ def search( # type: ignore # pylint: disable=too-many-arguments, arguments-differ
132
+ self,
133
+ **kwargs,
134
+ ) -> Union[ItemSearch, None]:
135
+ """Search items inside a specific collection."""
136
+
137
+ kwargs["collections"] = [
138
+ self.full_collection_id(kwargs["owner_id"], collection, "_") for collection in kwargs["collections"]
139
+ ] # type: ignore
140
+ return super().search(**kwargs) # type: ignore
141
+
142
+ # end of STAC read opperations
143
+
144
+ # STAC write opperations. These can't be done with pystac_client
145
+ # - add_collection
146
+ # - remove_collection
147
+ # - add_item
148
+ # - remove_item
190
149
 
191
150
  def add_collection(
192
151
  self,
@@ -234,7 +193,7 @@ class StacClient(RsClient, Client): # type: ignore # pylint: disable=too-many-a
234
193
  )
235
194
 
236
195
  # Update the links
237
- self.add_child(collection)
196
+ self.ps_client.add_child(collection)
238
197
 
239
198
  # Restore the short collection_id at the root of the collection
240
199
  collection.id = short_collection_id
@@ -244,7 +203,7 @@ class StacClient(RsClient, Client): # type: ignore # pylint: disable=too-many-a
244
203
 
245
204
  # Post the collection to the catalog
246
205
  return self.http_session.post(
247
- f"{self.href_catalog}/catalog/collections",
206
+ f"{self.href_service}/catalog/collections",
248
207
  json=collection.to_dict(),
249
208
  **self.apikey_headers,
250
209
  timeout=timeout,
@@ -270,19 +229,20 @@ class StacClient(RsClient, Client): # type: ignore # pylint: disable=too-many-a
270
229
  full_collection_id = self.full_collection_id(owner_id, collection_id)
271
230
 
272
231
  # Remove the collection from the "child" links of the local catalog instance
273
- collection_link = f"{self.self_href.rstrip('/')}/collections/{full_collection_id}"
274
- self.links = [
275
- link for link in self.links if not ((link.rel == pystac.RelType.CHILD) and (link.href == collection_link))
232
+ collection_link = f"{self.ps_client.self_href.rstrip('/')}/collections/{full_collection_id}"
233
+ self.ps_client.links = [
234
+ link
235
+ for link in self.ps_client.links
236
+ if not ((link.rel == pystac.RelType.CHILD) and (link.href == collection_link))
276
237
  ]
277
238
 
278
239
  # We need to clear the cache for this and parent "get_collection" methods
279
240
  # because their returned value must be updated.
280
- self.get_collection.cache_clear()
281
- Client.get_collection.cache_clear()
241
+ self.ps_client.get_collection.cache_clear()
282
242
 
283
243
  # Remove the collection from the server catalog
284
244
  return self.http_session.delete(
285
- f"{self.href_catalog}/catalog/collections/{full_collection_id}",
245
+ f"{self.href_service}/catalog/collections/{full_collection_id}",
286
246
  **self.apikey_headers,
287
247
  timeout=timeout,
288
248
  )
@@ -315,11 +275,11 @@ class StacClient(RsClient, Client): # type: ignore # pylint: disable=too-many-a
315
275
  collection = self.get_collection(collection_id, owner_id)
316
276
 
317
277
  # Update the item contents
318
- collection.add_item(item)
278
+ collection.add_item(item) # type: ignore
319
279
 
320
280
  # Post the item to the catalog
321
281
  return self.http_session.post(
322
- f"{self.href_catalog}/catalog/collections/{full_collection_id}/items",
282
+ f"{self.href_service}/catalog/collections/{full_collection_id}/items",
323
283
  json=item.to_dict(),
324
284
  **self.apikey_headers,
325
285
  timeout=timeout,
@@ -348,44 +308,9 @@ class StacClient(RsClient, Client): # type: ignore # pylint: disable=too-many-a
348
308
 
349
309
  # Remove the collection from the server catalog
350
310
  return self.http_session.delete(
351
- f"{self.href_catalog}/catalog/collections/{full_collection_id}/items/{item_id}",
311
+ f"{self.href_service}/catalog/collections/{full_collection_id}/items/{item_id}",
352
312
  **self.apikey_headers,
353
313
  timeout=timeout,
354
314
  )
355
315
 
356
- def search_inside_collection( # pylint: disable=too-many-arguments
357
- self,
358
- *,
359
- collection_id: str,
360
- owner_id: str | None = None,
361
- method: Optional[str] = "POST",
362
- max_items: Optional[int] = None,
363
- limit: Optional[int] = None,
364
- ids: Optional[IDsLike] = None,
365
- bbox: Optional[BBoxLike] = None,
366
- intersects: Optional[IntersectsLike] = None,
367
- datetime: Optional[DatetimeLike] = None,
368
- query: Optional[QueryLike] = None,
369
- stac_filter: Optional[FilterLike] = None,
370
- filter_lang: Optional[str] = None,
371
- sortby: Optional[SortbyLike] = None,
372
- fields: Optional[FieldsLike] = None,
373
- ) -> ItemSearch:
374
- """Search items inside a specific collection."""
375
-
376
- return Client.search(
377
- self,
378
- method=method,
379
- max_items=max_items,
380
- limit=limit,
381
- ids=ids,
382
- collections=[f"{owner_id}_{collection_id}"],
383
- bbox=bbox,
384
- intersects=intersects,
385
- datetime=datetime,
386
- query=query,
387
- filter=stac_filter,
388
- filter_lang=filter_lang,
389
- sortby=sortby,
390
- fields=fields,
391
- )
316
+ # end of STAC write opperations