p2f-client-py 0.0.11__tar.gz

p2f_client_py-0.0.11/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: p2f-client-py
+Version: 0.0.11
+Summary: API Client library for the Past to Future project.
+Author-email: Garrett Speed <g.t.speed@uu.nl>
+Project-URL: Homepage, https://github.com/Past-to-Future-EU-Horizon/p2f-client-py
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: furl>=2.1.4
+Requires-Dist: p2f-pydantic
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: requests>=2.32.3
+
+# p2f-client-py
+Python client library for the Past to Future projects Portal. Past to Future is an EU Horizon funded project. 
+
+## Installation
+
+    pip install git+https://github.com/Past-to-Future-EU-Horizon/p2f-client-py
+
+
+## Usage
+
+Create a client
+
+    from p2f_client import P2F_Client
+
+    client = P2F_Client("p2f-api.uu.nl", 8000)

p2f_client_py-0.0.11/README.md

@@ -0,0 +1,15 @@
+# p2f-client-py
+Python client library for the Past to Future projects Portal. Past to Future is an EU Horizon funded project. 
+
+## Installation
+
+    pip install git+https://github.com/Past-to-Future-EU-Horizon/p2f-client-py
+
+
+## Usage
+
+Create a client
+
+    from p2f_client import P2F_Client
+
+    client = P2F_Client("p2f-api.uu.nl", 8000)

p2f_client_py-0.0.11/p2f_client/conn.py

@@ -0,0 +1,32 @@
+import requests
+from furl import furl
+
+### We're having an issue with the API needing a connection
+###   open to actually get data into the portal. Here we're
+###   making a decorator function to probe the health-check
+###   endpoint first, opening the connection to the API. 
+
+def health_probe(base_url):
+    def health_probe_func_level(func):
+        base_url = furl(base_url)
+        prefix = "health-check"
+        healthcheckurl = base_url / f"{prefix}/"
+        r = requests.get(healthcheckurl)
+        if r.ok:
+            # Run the decorated function
+            def innerfunc(*args, **kwargs):
+                return func(*args, **kwargs)
+            return innerfunc
+        else:
+            # Due to above commented issue, if we can't get a GET, then raise an error
+            raise requests.exceptions.HTTPError("The client could not connect to the API server.")
+    return health_probe_func_level
+
+def health_check(base_url: furl):
+    prefix = "health-check"
+    healthcheck_url = base_url / f"{prefix}/"
+    r = requests.get(healthcheck_url)
+    if r.ok:
+        return True
+    else:
+        return False

p2f_client_py-0.0.11/p2f_client/datasets.py

@@ -0,0 +1,66 @@
+# Local libraries
+from p2f_pydantic.datasets import Datasets
+from .conn import health_check
+# Third Party Libraries
+import requests
+from furl import furl
+# Batteries included libraries
+from uuid import UUID
+from typing import Optional, List
+
+class datasets:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "datasets/"
+        self.dataset_url = self.base_url / self.prefix
+        self.upload_queue = []
+    def add_dataset(self, dataset: Datasets):
+        self.upload_queue.append(dataset)
+    def upload_datasets(self):
+        uploaded_datasets = []
+        if health_check(self.base_url):
+            for dataset in self.upload_queue:
+                r = requests.post(self.dataset_url,
+                                data=self.p2fclient.json_serialize_with_auth("dataset", dataset.model_dump_json(exclude_unset=True)),
+                                headers={"Content-Type": "application/json"})
+                uploaded_datasets.append(Datasets(**r.json()))
+            # self.uploaded_datasets = uploaded_datasets
+            return uploaded_datasets
+    def upload_dataset(self, dataset: Datasets):
+        if health_check(self.base_url):
+            r = requests.post(self.dataset_url,
+                            data=self.p2fclient.json_serialize_with_auth("dataset", dataset.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            return Datasets(**r.json())
+    def list_remote_datasets(self, 
+                             is_new_p2f: Optional[bool]=None,
+                             is_sub_dataset: Optional[bool]=None,
+                             doi: Optional[str]=None) -> List[Datasets]:
+        list_url = self.dataset_url
+        # data = {}
+        if is_new_p2f is not None:
+            list_url.args["is_new_p2f"] = is_new_p2f
+            # data["is_new_p2f"] = is_new_p2f
+        if is_sub_dataset is not None:
+            list_url.args["is_sub_dataset"] = is_sub_dataset
+            # data["is_sub_dataset"] = is_sub_dataset
+        if doi is not None:
+            list_url.args["doi"] = doi
+            # data["doi"] = doi
+        if health_check(self.base_url):
+            r = requests.get(list_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            # self.datasets = [Datasets(**x) for x in r.json()]
+            return [Datasets(**x) for x in r.json()]
+    def get_remote_dataset(self, dataset_id):
+        get_url = self.dataset_url / str(dataset_id)
+        if health_check(self.base_url):
+            r = requests.get(get_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return Datasets(**r.json())
+    def delete_remote_dataset(self, dataset_id):
+        delete_url = self.dataset_url / str(dataset_id)
+        if health_check(self.base_url):
+            r = requests.delete(delete_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})

p2f_client_py-0.0.11/p2f_client/doi.py

@@ -0,0 +1,38 @@
+import furl
+
+class doi:
+    def __init__(self, doi_input: str):
+        if doi_input.startswith("10"):
+            doi_split = doi_input.split("/")
+            print(doi_split)
+            if len(doi_split) == 2:
+                self.prefix, self.suffix = doi_split
+            else:
+                raise ValueError("The provided doi object does not conform to the prefix and suffix format.")
+        elif doi_input.startswith("http"):
+            url = furl.furl(doi_input)
+            match url.host:
+                case "doi.org": 
+                    print(url.path.segments)
+                    self.prefix = [x for x in url.path.segments if x.startswith("10")][0]
+                    self.suffix = url.path.segments[url.path.segments.index(self.prefix) + 1]
+                case "doi.pangaea.de":
+                    print(url.path.segments)
+                    self.prefix = [x for x in url.path.segments if x.startswith("10")][0]
+                    self.suffix = url.path.segments[url.path.segments.index(self.prefix) + 1]
+        elif doi_input.startswith("doi:"):
+            doi_input = doi_input[4:]
+            doi_split = doi_input.split("/")
+            print(doi_split)
+            if len(doi_split) == 2:
+                self.prefix, self.suffix = doi_split
+            else:
+                raise ValueError("The provided doi object does not conform to the prefix and suffix format.")
+        else:
+            raise ValueError("Unable to recognize the format of this doi")
+        self.url = furl.furl(f"https://doi.org/{self.prefix}/{self.suffix}")
+        self.string = f"{self.prefix}/{self.suffix}"
+    def __str__(self):
+        return self.string
+    def __repr__(self):
+        return f"<doi object prefix={self.prefix} suffix={self.suffix}>"

p2f_client_py-0.0.11/p2f_client/harm_data_record.py

@@ -0,0 +1,65 @@
+# Local libraries
+from p2f_pydantic.harm_data_record import HARM_Data_Record
+from .conn import health_check
+# Third Party Libraries
+import requests
+from furl import furl
+# Batteries included libraries
+from uuid import UUID
+from typing import Optional, List
+import hashlib
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+class harm_data_records:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "harm-data-records/"
+        self.hdr_url = self.base_url / self.prefix
+        self.harm_data_records_queue = []
+    def add_data_record(self, data_record: HARM_Data_Record):
+        self.harm_data_records_queue.append(data_record)
+    def upload_data_records(self):
+        uploaded_records = []
+        if health_check(self.base_url):
+            for record in self.harm_data_records_queue:
+                r = requests.post(self.hdr_url,
+                                data=self.p2fclient.json_serialize_with_auth("new_data_record", record.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+                record.append(HARM_Data_Record(**r.json()))
+            self.uploaded_records = uploaded_records
+            return uploaded_records
+    def upload_data_record(self, data_record: HARM_Data_Record):
+        if health_check(self.base_url):
+            r = requests.post(self.hdr_url,
+                            data=self.p2fclient.json_serialize_with_auth("new_data_record", data_record.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Data_Record(**r.json())
+    def list_remote_records(self, 
+                            dataset: Optional[str]=None,
+                            data_type: Optional[str]=None):
+        params = {"dataset": dataset,
+                  "data_type": data_type}
+        params = {x:y for x, y in params.items() if y != None}
+        if health_check(self.base_url):
+            r = requests.get(self.hdr_url,
+                            params=params, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return [HARM_Data_Record(**x) for x in r.json()]
+    def get_remote_record(self, record_hash: str):
+        if health_check(self.base_url):
+            r = requests.get(self.hdr_url / record_hash, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Data_Record(**r.json())
+    def delete_remote_dataset(self, record_hash: str):
+        if health_check(self.base_url):
+            r = requests.delete(self.hdr_url / record_hash, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+    def calculate_hash(self, dataset_id, row_number, debugging=False):
+        hasher = hashlib.md5()
+        hasher.update(str(dataset_id).encode("utf8"))
+        hasher.update(str(row_number).encode("utf8"))
+        if debugging == True:
+            hasher.update(str(datetime.now(tz=ZoneInfo("UTC")).isoformat(sep="T")).encode("utf8"))
+        return str(hasher.hexdigest())

p2f_client_py-0.0.11/p2f_client/harm_data_types.py

@@ -0,0 +1,58 @@
+# Local libraries
+from p2f_pydantic.harm_data_types import HARM_Data_Type
+from .conn import health_check
+# Third Party Libraries
+import requests
+from furl import furl
+# Batteries included libraries
+from uuid import UUID
+from typing import Optional, List
+
+class harm_data_type:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "harm-data-types/"
+        self.hdt_url = self.base_url / self.prefix
+        self.harm_data_types_queue = []
+    def add_harm_data_type(self, new_data_type: HARM_Data_Type):
+        self.harm_data_types_queue.append(new_data_type)
+    def upload_data_types(self):
+        if health_check(self.base_url):
+            for datatype in self.harm_data_types_queue:
+                r = requests.post(self.hdt_url, 
+                                  data=self.p2fclient.json_serialize_with_auth("new_harm_data_type", datatype.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+    def upload_data_type(self, new_data_type: HARM_Data_Type):
+        if health_check(self.base_url):
+            r = requests.post(self.hdt_url, 
+                              data=self.p2fclient.json_serialize_with_auth("new_harm_data_type", new_data_type.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Data_Type(**r.json())
+    def list_data_types(self, 
+                        measure: Optional[str]=None,
+                        unit_of_measure: Optional[str]=None,
+                        method: Optional[str]=None, 
+                        dataset_id: Optional[UUID]=None):
+        params = {"measure": measure,
+                  "unit_of_measure": unit_of_measure,
+                  "method": method, 
+                  "dataset_id": dataset_id}
+        params = {x:y for x, y in params.items() if y != None}
+        if health_check(self.base_url):
+            r = requests.get(self.hdt_url,
+                            params=params, 
+                            data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return [HARM_Data_Type(**x) for x in r.json()]
+    def get_data_type(self, datatype_id: UUID):
+        if health_check(self.base_url):
+            r = requests.get(self.hdt_url / datatype_id, 
+                             data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Data_Type(**r.json())
+    def delete_data_type(self, datatype_id: UUID):
+        if health_check(self.base_url):
+            r = requests.delete(self.hdt_url / datatype_id, 
+                                data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})

p2f_client_py-0.0.11/p2f_client/harm_location.py

@@ -0,0 +1,77 @@
+# Local libraries
+from p2f_pydantic.harm_data_metadata import HARM_Bounding_Box, HARM_Location
+from .conn import health_check
+# Third Party Libraries
+import requests
+from furl import furl
+# Batteries included libraries
+from uuid import UUID
+from typing import Optional, List, Union
+
+class harm_location:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "harm-data-locations/"
+        self.hdl_url = self.base_url / self.prefix
+        self.harmonized_location_queue = []
+    def add_harm_location(self, new_location: HARM_Location):
+        self.harmonized_location_queue.append(new_location)
+    def upload_harm_locations(self):
+        inserted_locations = []
+        if health_check(self.base_url):
+            for location in self.harmonized_location_queue:
+                r = requests.post(self.hdl_url, 
+                                  data=self.p2fclient.json_serialize_with_auth("new_location", location.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+                inserted_locations.append(HARM_Location(**r.json()))
+            return inserted_locations
+    def upload_harm_location(self, new_location: HARM_Location):
+        if health_check(self.base_url):
+            r = requests.post(self.hdl_url, 
+                              data=self.p2fclient.json_serialize_with_auth("new_location", new_location.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Location(**r.json())
+    def list_harm_locations(self,
+                            bounding_box: Optional[HARM_Bounding_Box]=None,
+                            location_name: Optional[str]=None, 
+                            location_code: Optional[str]=None, 
+                            minimum_elevation: Optional[float]=None,
+                            maximum_elevation: Optional[float]=None,
+                            min_location_age: Optional[float]=None,
+                            max_location_age: Optional[float]=None, 
+                            dataset_id: Optional[UUID]=None):
+        params = {
+            "bounding_box": bounding_box,
+            "location_name": location_name,
+            "location_code": location_code, 
+            "minimum_elevation": minimum_elevation,
+            "maximum_elevation": maximum_elevation,
+            "min_location_age": min_location_age,
+            "max_location_age": max_location_age,
+            "dataset_id": dataset_id
+            }
+        params = {x: y for x, y in params.items() if y != None}
+        if health_check(self.base_url):
+            r = requests.get(self.hdl_url,
+                            params=params, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return [HARM_Location(**x) for x in r.json()]
+    def get_harm_location(self, location_identifier: UUID):
+        if health_check(self.base_url):
+            r = requests.get(self.hdl_url/str(location_identifier), data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Location(**r.json())
+    def delete_harm_location(self, location_identifier: UUID):
+        if health_check(self.base_url):
+            r = requests.delete(self.hdl_url/str(location_identifier), data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+    def assign_location_to_record(self, location_identifier: UUID, record_hash: str):
+        # params = {"location_identifier": str(location_identifier),
+        #           "record_hash": record_hash}
+        assign_url = self.hdl_url / "assign"
+        assign_url.args["location_identifier"] = str(location_identifier)
+        assign_url.args["record_hash"] = record_hash
+        if health_check(self.base_url):
+            r = requests.post(assign_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})

p2f_client_py-0.0.11/p2f_client/harm_numerical.py

@@ -0,0 +1,84 @@
+# Local libraries
+from p2f_pydantic.harm_data_numerical import HARM_Float, HARM_Float_Confidence
+from p2f_pydantic.harm_data_numerical import HARM_Int, HARM_Int_Confidence
+from p2f_pydantic.harm_data_numerical import Insert_HARM_Numerical, Return_HARM_Numerical
+from .conn import health_check
+# Third Party Libraries
+import requests
+from furl import furl
+# Batteries included libraries
+from uuid import UUID
+from typing import Optional, List, Union, Literal
+
+Harm_numerical_union = Union[HARM_Int, HARM_Int_Confidence, HARM_Float, HARM_Float_Confidence]
+
+class harm_numerical:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "harm-numerical/"
+        self.hdn_url = self.base_url / self.prefix
+        self.harmonized_numerical_records_queue = []
+    def add_harm_numerical(self, new_numerical_record: Insert_HARM_Numerical):
+        self.harmonized_numerical_records_queue.append(new_numerical_record)
+    def upload_harm_numericals(self):
+        inserted_numericals = []
+        if health_check(self.base_url):
+            for nummer in self.harmonized_numerical_records_queue:
+                r = requests.post(self.hdn_url, 
+                                  data=self.p2fclient.json_serialize_with_auth("new_numeric", nummer.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+                inserted_numericals.append(self.identify_numeric_object(r.json(), nummer.model_dump_json(exclude_unset=True)))
+            return inserted_numericals
+    def upload_harm_numerical(self, new_record: Insert_HARM_Numerical):
+        if health_check(self.base_url):
+            r = requests.post(self.hdn_url, data=self.p2fclient.json_serialize_with_auth("new_numeric", new_record.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            return self.identify_numeric_object(r.json(), new_record.model_dump(exclude_unset=True))
+    def list_harm_numericals(self, 
+                             record_hash: Optional[str]=None,
+                             numeric_type: Optional[Literal["float_confidence", 
+                                                        "float", 
+                                                        "int_confidence", 
+                                                        "int"]]=None, 
+                             data_type: Optional[UUID]=None, 
+                             dataset_id: Optional[UUID]=None):
+        params = {
+            "record_hash": record_hash,
+            "numeric_type": numeric_type,
+            "data_type": data_type,
+            "dataset_id": dataset_id
+        }
+        params = {x:y for x, y in params.items() if y != None}
+        if health_check(self.base_url):
+            r = requests.get(self.hdn_url, 
+                            params=params, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return Return_HARM_Numerical(**r.json())
+    def identify_numeric_object(self, 
+                                incoming_json, 
+                                original: Optional[Insert_HARM_Numerical]=None) -> Harm_numerical_union:
+        if original:
+            number_type = original["numerical_type"]
+        else:
+            incoming_value = incoming_json["value"]
+            if "." in str(incoming_value):
+                number_type = "FLOAT"
+            else:
+                number_type = "INT"
+        if "upper_conf_value" in incoming_json.keys():
+            number_type += "_CONFIDENCE"
+        match number_type:
+            case "INT":
+                rv = HARM_Int(**incoming_json)
+            case "INT_CONFIDENCE":
+                rv = HARM_Int_Confidence(**incoming_json)
+            case "FLOAT":
+                rv = HARM_Float(**incoming_json)
+            case "FLOAT_CONFIDENCE":
+                rv = HARM_Float_Confidence(**incoming_json)
+        return rv
+        
+
+
+    

p2f_client_py-0.0.11/p2f_client/harm_reference.py

@@ -0,0 +1,68 @@
+# Local libraries
+from p2f_pydantic.harm_reference import HARM_Reference
+from .conn import health_check
+# Third Party Libraries
+import requests
+# Batteries included libraries
+from typing import Optional, List
+from uuid import UUID
+
+class harm_reference:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "harm-reference/"
+        self.hr_url = self.base_url / self.prefix
+        self.harmonized_reference_queue = []
+    def add_harm_reference(self, new_reference: HARM_Reference):
+        self.harmonized_reference_queue.append(new_reference)
+    def upload_harm_reference_queue(self) -> List[HARM_Reference]:
+        inserted_harm_references = []
+        if health_check(self.base_url):
+            for ref in self.harmonized_reference_queue:
+                r = requests.post(self.hr_url, data=self.p2fclient.json_serialize_with_auth("new_reference", ref.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+                inserted_harm_references.append(HARM_Reference(**r.json()))
+            return inserted_harm_references
+    def upload_harm_reference(self, new_reference: HARM_Reference) -> HARM_Reference:
+        if health_check(self.base_url):
+            r = requests.post(self.hr_url, data=self.p2fclient.json_serialize_with_auth("new_reference", new_reference.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            if r.ok:
+                return (HARM_Reference(**r.json()))
+    def list_harm_references(self) -> List[HARM_Reference]:
+        if health_check(self.base_url):
+            r = requests.get(self.hr_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            if r.ok:
+                return [HARM_Reference(**x) for x in r.json()]
+            else:
+                return []
+    def get_harm_reference(self, reference_id: UUID) -> HARM_Reference:
+        if health_check(self.base_url):
+            r = requests.get(self.hr_url / reference_id, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            if r.ok:
+                return HARM_Reference(**r.json())
+    def delete_harm_reference(self, reference_id: UUID):
+        if health_check(self.base_url):
+            r = requests.delete(self, reference_id, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+    def assign_harm_reference(self, 
+                              reference_id: UUID, 
+                              record_hash: str):
+        assign_url = self.hr_url
+        assign_url.args["reference_id"] = reference_id
+        assign_url.args["record_hash"] = record_hash
+        if health_check(self.base_url):
+            r = requests.post(assign_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+    def remove_harm_reference(self, 
+                              reference_id: UUID, 
+                              record_hash: str):
+        assign_url = self.hr_url
+        assign_url.args["reference_id"] = reference_id
+        assign_url.args["record_hash"] = record_hash
+        if health_check(self.base_url):
+            r = requests.delete(assign_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})

p2f_client_py-0.0.11/p2f_client/harm_species.py

@@ -0,0 +1,76 @@
+# Local libraries
+from p2f_pydantic.harm_data_metadata import HARM_Data_Species
+from .conn import health_check
+# Third Party Libraries
+import requests
+# Batteries included libraries
+from typing import Optional, List
+from uuid import UUID
+
+class harm_species:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "harm-data-species/"
+        self.hds_url = self.base_url / self.prefix
+        self.harmonized_species_queue = []
+    def add_harm_species(self, new_species: HARM_Data_Species):
+        self.harmonized_species_queue.append(new_species)
+    def upload_harm_species_queue(self) -> List[HARM_Data_Species]:
+        inserted_species = []
+        if health_check(self.base_url):
+            for record in self.harmonized_species_queue:
+                r = requests.post(self.hds_url, 
+                                  data=self.p2fclient.json_serialize_with_auth("new_species", record.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+                inserted_species.append(HARM_Data_Species(**r.json()))
+            return inserted_species
+    def upload_harm_species(self, new_species: HARM_Data_Species):
+        if health_check(self.base_url):
+            r = requests.post(self.hds_url, 
+                              data=self.p2fclient.json_serialize_with_auth("new_species", new_species.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Data_Species(**r.json())
+    def list_harm_species(self, 
+                          tax_domain: Optional[str]=None,
+                          tax_kingdom: Optional[str]=None,
+                          tax_subkingdom: Optional[str]=None,
+                          tax_infrakingdom: Optional[str]=None,
+                          tax_phylum: Optional[str]=None,
+                          tax_class: Optional[str]=None,
+                          tax_subclass: Optional[str]=None,
+                          tax_order: Optional[str]=None,
+                          tax_suborder: Optional[str]=None,
+                          tax_superfamily: Optional[str]=None,
+                          tax_family: Optional[str]=None,
+                          tax_subfamily: Optional[str]=None,
+                          tax_genus: Optional[str]=None,
+                          tax_species: Optional[str]=None,
+                          tax_subspecies: Optional[str]=None,
+                          common_name: Optional[str]=None,
+                          display_species: Optional[str]=None,) -> HARM_Data_Species:
+        params = {x: y for x, y in locals().items() if x.startswith("tax_")}
+        params["common_name"] = common_name
+        params["display_species"] = display_species
+        params = {x: y for x, y in params.items() if y != None}
+        if health_check(self.base_url):
+            r = requests.get(self.hds_url, 
+                            params=params, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return [HARM_Data_Species(**x) for x in r.json()]
+    def get_harm_species(self, species_identifier: UUID):
+        if health_check(self.base_url):
+            r = requests.get(self.hds_url/species_identifier, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Data_Species(**r.json())
+    def delete_harm_species(self, species_identifier: UUID):
+        if health_check(self.base_url):
+            r = requests.delete(self.hds_url/species_identifier, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+    def assign_species_to_record(self, species_identifier: UUID, record_hash: str):
+        assign_url = self.hds_url / "assign"
+        assign_url.args["species_id"] = species_identifier
+        assign_url.args["record_hash"] = record_hash
+        if health_check(self.base_url):
+            r = requests.post(assign_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})

p2f_client_py-0.0.11/p2f_client/harm_timeslice.py

@@ -0,0 +1,75 @@
+# Local libraries
+from p2f_pydantic.harm_timeslices import HARM_Timeslice
+from .conn import health_check
+# Third Party Libraries
+import requests
+# Batteries included libraries
+from uuid import UUID
+from typing import Optional, List
+
+class harm_timeslice:
+    def __init__(self, p2fclient):
+        self.p2fclient = p2fclient
+        self.base_url = p2fclient.base_url
+        self.prefix = "harm-timeslice/"
+        self.ht_url = self.base_url / self.prefix
+        self.harmonized_timeslice_queue = []
+    def add_timeslice(self, new_timeslice: HARM_Timeslice):
+        self.harmonized_timeslice_queue.append(new_timeslice)
+    def upload_timeslice_queue(self):
+        inserted_timeslice_list = []
+        if health_check(self.base_url):
+            for timeslice in self.harmonized_timeslice_queue:
+                r = requests.post(self.ht_url, 
+                                  data=self.p2fclient.json_serialize_with_auth("new_harm_timeslice", timeslice.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+                inserted_timeslice_list.append(HARM_Timeslice(**r.json()))
+            return inserted_timeslice_list
+    def upload_timeslice(self, new_timeslice: HARM_Timeslice) -> HARM_Timeslice:
+        if health_check(self.base_url):
+            r = requests.post(self.ht_url, 
+                              data=self.p2fclient.json_serialize_with_auth("new_harm_timeslice", new_timeslice.model_dump_json(exclude_unset=True)),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Timeslice(**r.json())
+    def list_timeslices(self,
+                        named_time_period: Optional[str]=None, 
+                        older_search_age: Optional[int]=None,
+                        recent_search_age: Optional[int]=None,) -> List[HARM_Timeslice]:
+        params = {"named_time_period": named_time_period,
+                  "older_search_age": older_search_age,
+                  "recent_search_age": recent_search_age}
+        params = {x: y for x, y in params.items() if y != None}
+        if health_check(self.base_url):
+            r = requests.get(self.ht_url, 
+                            params=params, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return [HARM_Timeslice(**x) for x in r.json()]
+    def get_timeslice(self, 
+                      timeslice_id: UUID) -> HARM_Timeslice:
+        if health_check(self.base_url):
+            r = requests.get(self.ht_url / timeslice_id, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+            return HARM_Timeslice(**r.json())
+    def delete_timeslice(self, 
+                         timeslice_id: UUID) -> HARM_Timeslice:
+        if health_check(self.base_url):
+            r = requests.delete(self.ht_url / timeslice_id, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+    def assign_timeslice(self, 
+                         timeslice_id: UUID, 
+                         record_hash: str):
+        assign_url = self.ht_url / "assign"
+        assign_url.args["timeslice_id"] = timeslice_id
+        assign_url.args["record_hash"] = record_hash
+        if health_check(self.base_url):
+            r = requests.post(assign_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})
+    def remove_timeslice(self, 
+                         timeslice_id: UUID, 
+                         record_hash: str):
+        remove_url = self.ht_url / "remove"
+        remove_url.args["timeslice_id"] = timeslice_id
+        remove_url.args["record_hash"] = record_hash
+        if health_check(self.base_url):
+            r = requests.delete(remove_url, data=self.p2fclient.json_serialize_with_auth(),
+                            headers={"Content-Type": "application/json"})

p2f_client_py-0.0.11/p2f_client/p2f_client.py

@@ -0,0 +1,84 @@
+# Local libraries
+from .datasets import datasets
+from .harm_data_record import harm_data_records
+from .harm_data_types import harm_data_type
+from .harm_numerical import harm_numerical
+from .harm_location import harm_location
+from .harm_species import harm_species
+from .harm_timeslice import harm_timeslice
+from .harm_reference import harm_reference
+from .conn import health_check
+from p2f_pydantic.temp_accounts import Temp_Account
+# Third Party Libraries
+import requests
+import furl
+# Batteries included libraries
+from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
+from typing import Optional
+
+
+class P2F_Client:
+    def __init__(self, 
+                 hostname: str, 
+                 port: int=443, 
+                 https: bool=True, 
+                 email: Optional[str]=None, 
+                 token: Optional[str] = None, 
+                 token_expiration: Optional[datetime]=None):
+        self.version = (0, 0, 10) # turn this into a real named tuple one day
+        self.hostname = hostname
+        self.port = port
+        if https:
+            self.protocol = "https"
+        else:
+            self.protocol = "http"
+        self.host_url = f"{self.protocol}://{self.hostname}:{self.port}"
+        self.base_url = furl.furl(self.host_url)
+        self.email= email
+        self.token = token
+        if self.token is not None:
+            if token_expiration is None:
+                # It's not true, but it does inform us that the token could possibly last till tomorrow
+                self.TOKEN_EXPIRATION = datetime.now(tz=ZoneInfo("UTC")) + timedelta(hours=24)
+                raise UserWarning("A generic token expiration time was used, the token could expire sooner than the currently set token expiration time")
+            else: 
+                self.TOKEN_EXPIRATION = token_expiration
+            if self.email is not None:
+                self.temp_account = Temp_Account(email=self.email, token=self.token)
+        self.child_class_loading()
+    def child_class_loading(self):
+        # Separated this out so we can reload it later. 
+        self.datasets = datasets(self)
+        self.harm_data_records = harm_data_records(self)
+        self.harm_data_type = harm_data_type(self)
+        self.harm_numerical = harm_numerical(self)
+        self.harm_location = harm_location(self)
+        self.harm_species = harm_species(self)
+        self.harm_timeslice = harm_timeslice(self)
+        self.harm_reference = harm_reference(self)
+    def request_token(self):
+        # self.email = email
+        self.token_url = self.base_url / "token"
+        self.token_request_url = self.token_url / "request"
+        token_request_model = Temp_Account(email=self.email)
+        # calculate the datetime of the token before making the request
+        #    so that our expiration time is just before actual expiration. 
+        self.TOKEN_EXPIRATION = datetime.now(tz=ZoneInfo("UTC")) + timedelta(hours=24)
+        if health_check(self.base_url):
+            r = requests.post(self.token_request_url, 
+                              data=token_request_model.model_dump_json(exclude_unset=True),
+                              headers={"Content-Type": "application/json"})
+            print(r.json())
+    def set_token(self, token: str):
+        self.token = token
+        self.temp_account = Temp_Account(email=self.email, token=self.token)
+        # reload the child classes so they will have the token
+        self.child_class_loading()
+    def json_serialize_with_auth(self, 
+                                 label: Optional[str]=None, 
+                                 JSON_str: Optional[str]=None):
+        if label is not None:
+            return f"""{{"auth":{self.temp_account.model_dump_json(exclude_unset=True)},"{label}":{JSON_str}}}"""
+        if label is None:
+            return self.temp_account.model_dump_json(exclude_unset=True)

p2f_client_py-0.0.11/p2f_client_py.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: p2f-client-py
+Version: 0.0.11
+Summary: API Client library for the Past to Future project.
+Author-email: Garrett Speed <g.t.speed@uu.nl>
+Project-URL: Homepage, https://github.com/Past-to-Future-EU-Horizon/p2f-client-py
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: furl>=2.1.4
+Requires-Dist: p2f-pydantic
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: requests>=2.32.3
+
+# p2f-client-py
+Python client library for the Past to Future projects Portal. Past to Future is an EU Horizon funded project. 
+
+## Installation
+
+    pip install git+https://github.com/Past-to-Future-EU-Horizon/p2f-client-py
+
+
+## Usage
+
+Create a client
+
+    from p2f_client import P2F_Client
+
+    client = P2F_Client("p2f-api.uu.nl", 8000)

p2f_client_py-0.0.11/p2f_client_py.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+p2f_client/__init__.py
+p2f_client/conn.py
+p2f_client/datasets.py
+p2f_client/doi.py
+p2f_client/harm_data_record.py
+p2f_client/harm_data_types.py
+p2f_client/harm_location.py
+p2f_client/harm_numerical.py
+p2f_client/harm_reference.py
+p2f_client/harm_species.py
+p2f_client/harm_timeslice.py
+p2f_client/p2f_client.py
+p2f_client_py.egg-info/PKG-INFO
+p2f_client_py.egg-info/SOURCES.txt
+p2f_client_py.egg-info/dependency_links.txt
+p2f_client_py.egg-info/requires.txt
+p2f_client_py.egg-info/top_level.txt

p2f_client_py-0.0.11/p2f_client_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

p2f_client_py-0.0.11/p2f_client_py.egg-info/requires.txt

@@ -0,0 +1,6 @@
+furl>=2.1.4
+p2f-pydantic
+pandas>=2.3.3
+pyjwt>=2.10.1
+python-dotenv>=1.1.0
+requests>=2.32.3

p2f_client_py-0.0.11/p2f_client_py.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+p2f_client

p2f_client_py-0.0.11/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "p2f-client-py"
+version = "0.0.11"
+description = "API Client library for the Past to Future project."
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "furl>=2.1.4",
+    "p2f-pydantic",
+    "pandas>=2.3.3",
+    "pyjwt>=2.10.1",
+    "python-dotenv>=1.1.0",
+    "requests>=2.32.3",
+]
+authors = [
+    { name="Garrett Speed", email="g.t.speed@uu.nl"} 
+]
+
+[project.urls]
+Homepage = "https://github.com/Past-to-Future-EU-Horizon/p2f-client-py"
+
+[tool.setuptools.packages.find]
+exclude = ["Pliocene_SSTs"]

p2f_client_py-0.0.11/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+