pymetadataeditor 0.1.0__py3-none-any.whl

pymetadataeditor/llm_helpers.py

@@ -0,0 +1,145 @@
+from datetime import datetime
+from typing import Any, get_args
+
+from metadataschemas.utils.quick_start import make_skeleton
+from metadataschemas.utils.utils import is_list_annotation, is_optional_annotation
+from pydantic import BaseModel, ValidationError
+
+
+def _prepend_draft_drop_non_str(d: Any, prefix: str) -> dict | list | str | None:
+    """
+    Recursively prepend a prefix to all strings in a dictionary or list and drop empty strings and non-strings.
+
+    Args:
+
+        d (Any): The dictionary or list to process.
+    """
+
+    if isinstance(d, dict):
+        out = {}
+        for k, v in d.items():
+            new_v = _prepend_draft_drop_non_str(v, prefix)
+            if new_v is not None:
+                out[k] = new_v
+        if len(out) > 0:
+            return out
+        else:
+            return None
+    elif isinstance(d, list):
+        out = []
+        for v in d:
+            new_v = _prepend_draft_drop_non_str(v, prefix)
+            if new_v is not None:
+                out.append(new_v)
+        if len(out) > 0:
+            return out
+        else:
+            return None
+    elif isinstance(d, str):
+        if d.strip() == "":
+            return None
+        else:
+            return prefix + d
+    else:
+        return None
+
+
+def _iterated_validated_update_to_outline(model_def: type[BaseModel], updates: dict, verbose=False) -> BaseModel:
+    original_model = make_skeleton(model_def).model_dump()
+    # print(original_model)
+    model_def.model_validate(original_model, strict=False)
+
+    model_fields = model_def.model_fields
+    for key, value in updates.items():
+        if key not in original_model:
+            continue
+
+        # get annotation aka type of the field
+        annotation = model_fields[key].annotation
+        if is_optional_annotation(annotation):
+            annotation = get_args(annotation)[0]
+        is_list = False
+        if is_list_annotation(annotation):
+            annotation = get_args(annotation)[0]
+            is_list = True
+        # print(annotation)
+
+        # get candidate value
+        if isinstance(value, dict) and issubclass(annotation, BaseModel):
+            candidate_value = _iterated_validated_update_to_outline(annotation, value, verbose=verbose).model_dump()
+        elif is_list and isinstance(value, list) and issubclass(annotation, BaseModel):
+            candidate_value = []
+            for item in value:
+                candidate_value.append(
+                    _iterated_validated_update_to_outline(annotation, item, verbose=verbose).model_dump()
+                )
+        else:
+            candidate_value = value
+
+        # try the candidate value
+        original_value = original_model[key]
+        original_model[key] = candidate_value
+        try:
+            model_def.model_validate(original_model, strict=False)
+        except ValidationError as e:
+            # If validation fails, leave the original value
+            if verbose:
+                print(f"Skipping {key}({annotation})={candidate_value} because of {e}\n")
+            original_model[key] = original_value
+        # print(original_model)
+
+    return model_def.model_validate(original_model, strict=False)
+
+
+def get_date_as_text():
+    """
+    Returns the current date as a formatted string with an ordinal suffix for the day.
+
+    The format of the returned date string is "Month DaySuffix, Year", where:
+    - Month is the full name of the month (e.g., January, February).
+    - DaySuffix is the day of the month with an appropriate ordinal suffix (e.g., 1st, 2nd, 3rd, 4th, etc.).
+    - Year is the four-digit year.
+
+    Example:
+        If today's date is October 21, 2023, the function will return "October 21st, 2023".
+
+    Returns:
+        str: The formatted date string.
+    """
+    today = datetime.today()
+    day = today.day
+    # Determine ordinal suffix
+    if 10 <= day % 100 <= 20:
+        suffix = "th"
+    else:
+        suffix = {1: "st", 2: "nd", 3: "rd"}.get(day % 10, "th")
+
+    # Format the date
+    return today.strftime(f"%B %-d{suffix}, %Y")
+
+
+def json_to_markdown(data, level=1):
+    """
+    Converts a JSON object into Markdown.  Future versions of MarkItDown will support this natively.
+
+    Args:
+        data: The JSON object (dict, list, or primitive type).
+        level: Current Markdown heading level for nested keys.
+
+    Returns:
+        A Markdown string.
+    """
+    markdown = ""
+
+    if isinstance(data, dict):
+        for key, value in data.items():
+            markdown += f"{'#' * level} {key}\n\n"  # Add heading for the key
+            markdown += json_to_markdown(value, level + 1)  # Recursively process value
+    elif isinstance(data, list):
+        for item in data:
+            markdown += f"- {json_to_markdown(item, level + 1).strip()}\n"  # Format as a list
+    else:
+        # Format primitive types (string, number, boolean, null)
+        markdown += f"{data}\n\n"
+
+    return markdown

pymetadataeditor/requester.py

@@ -0,0 +1,160 @@
+from io import BufferedReader
+from json import JSONDecodeError
+from ssl import SSLError as ssl_SSLError
+from typing import Any, Dict, List, Optional, Union
+
+import requests
+from pydantic import AnyHttpUrl, BaseModel, ConfigDict, Field, SecretStr, model_validator
+from requests.exceptions import HTTPError, SSLError
+
+
+class RequestsWithSpecificErrors(BaseModel):
+    model_config = ConfigDict(extra="forbid", validate_assignment=True)
+
+    api_url: AnyHttpUrl
+    api_key: SecretStr = Field(repr=False)
+    allow_http: bool = Field(
+        default=False,
+        description="API urls that begin HTTPS are favoured. Set allow_http=True to use of the less secure HTTP",
+    )
+    verify_ssl: bool = Field(
+        default=True,
+        description="Calls to the API are authenticated with an SSL certificate. "
+        "Set verify_ssl=False to remove this requirement",
+    )
+
+    @model_validator(mode="after")
+    def _check_https(self) -> Any:
+        if str(self.api_url).startswith("https") or self.allow_http:
+            return self
+        else:
+            raise ValueError(
+                f"URL scheme should be 'https' but got {self.api_url}"
+                "To allow the less secure use of 'http', set allow_unsecure=True"
+            )
+
+    def _request(
+        self,
+        method: str,
+        pth: str,
+        json: Optional[Dict] = None,
+        params: Optional[Dict[str, Union[str, List[str]]]] = None,
+        id: Optional[Union[int, str]] = None,
+        data: Optional[Dict[str, str]] = None,
+        files: Optional[Dict[str, BufferedReader]] = None,
+    ) -> Dict:
+        """
+        Sends a GET or POST request to the specified URL with the API key in the headers and returns the JSON response.
+
+        Args:
+            method (str): Either post or get
+            pth (str): The path appended to the API_URL to which the GET or POST request is sent.
+
+        Returns:
+            Dict[str, str]: The JSON response from the server, parsed into a dictionary.
+
+        Raises:
+            ValueError: If the URL does not start with 'https'.
+            PermissionError: If the response status code is 403, indicating that access is denied.
+            Exception: If the request fails due to other HTTP errors, with details of the status code and response text.
+            Exception: If any other unexpected error occurs during the request.
+        """
+        method = method.lower()
+        assert method in ["get", "post"], f"unknown method {method}"
+        request_kwargs = {}
+        if method == "post":
+            assert params is None, "when using post, pass json not params"
+            request_kwargs["json"] = json
+            if data is not None:
+                request_kwargs["data"] = data
+            if files is not None:
+                request_kwargs["files"] = files
+        if method == "get" and params is not None:
+            assert json is None, "when using get, pass params not json"
+            request_kwargs["params"] = params
+
+        if "{" in pth:
+            assert id is not None, "If passing a url format, an id must be passed"
+            pth = pth.format(id)
+        url = str(self.api_url).strip("/") + "/" + pth.strip("/")
+        try:
+            response = None
+            response = requests.request(
+                method,
+                url,
+                verify=self.verify_ssl,
+                headers={"x-api-key": self.api_key.get_secret_value()},
+                **request_kwargs,
+            )
+            response.raise_for_status()
+        except (SSLError, ssl_SSLError) as e:
+            raise SSLError(
+                f"Usually this means the admin of {self.api_url} has not verified an SSL certificate.\n"
+                f"You can bypass the requirement by setting MetadataEditor.verify_ssl=False.\n{e}"
+            ) from None
+        except HTTPError as e:
+            if response is None or response.status_code == 404:
+                error_msg = (
+                    f"Page not found. Try checking the URL.\nGenerally the required URL looks like "
+                    f"'https://<name_of_your_metadata_database>.org/index.php/api', but the URL that was passed "
+                    f"was '{self.api_url}'"
+                )
+                raise HTTPError(error_msg) from None
+            elif response.status_code == 403:
+                raise PermissionError(
+                    f"Access to that URL is denied for {url} " "Check that the API key is correct"
+                ) from e
+            elif response.status_code == 400 and "message" in response.text:
+                if isinstance(response.text, dict):
+                    error_message = response.text["message"]
+                else:
+                    error_message = response.text
+                raise PermissionError(error_message) from e
+            else:
+                raise HTTPError(f"Status Code: {response.status_code}, Response: {response.text}") from e
+        try:
+            json_response = response.json()
+        except (JSONDecodeError, requests.exceptions.JSONDecodeError) as e:
+            raise JSONDecodeError(
+                f"Error decoding JSON response: {e.msg}\n{response.text}\nFull Response: {response}", e.doc, e.pos
+            ) from e
+        # if self.verify_ssl == False:
+        # we must have shown this warning the first time, ok to silence thereafter
+        return json_response
+
+    def get_request(
+        self, pth: str, id: Optional[Union[int, str]] = None, params: Optional[Dict[str, Union[str, List[str]]]] = None
+    ) -> Dict:
+        """
+        Args:
+            pth (str): The path appended to the API_URL to which the GET request is sent.
+            id (optional int or str): The id of a specific collection or project.
+                                        If not none, then pth should contain '{}' where the id ought to go.
+            params (optional dict): additional parameters to send with the get request such as 'keywords'
+
+        Returns:
+            Dict[str, str]: The JSON response from the server, parsed into a dictionary.
+        """
+        return self._request("get", pth=pth, id=id, params=params)
+
+    def post_request(
+        self,
+        pth: str,
+        json: Optional[Dict] = None,
+        id: Optional[Union[int, str]] = None,
+        data: Optional[Dict[str, str]] = None,
+        files: Optional[Dict[str, BufferedReader]] = None,
+    ):
+        """
+        Args:
+            pth (str): The path appended to the API_URL to which the POST request is sent.
+            json (optional dict): The JSON data to send with the POST request.
+            id (optional int or str): The id of a specific project, collection or template etc.
+                                        If not none, then pth should contain '{}' where the id ought to go.
+            data (optional dict): The data to send with the POST request.
+            files (optional dict): The files to send with the POST request.
+
+        Returns:
+            Dict[str, str]: The JSON response from the server, parsed into a dictionary.
+        """
+        return self._request("post", pth=pth, id=id, json=json, data=data, files=files)