renamed pythonized to native python

Author: notactuallyfinn

src/hermes/commands/deposit/invenio.py

@@ -616,7 +616,7 @@ def _codemeta_to_invenio_deposition(self) -> dict:
         if len(keywords) == 0:
             keywords = None
         else:
-            keywords = keywords.to_python()
+            keywords = keywords.to_native_python()
 
         # TODO: Use the fields currently set to `None`.
         # Some more fields are available but they most likely don't relate to software

src/hermes/model/api.py

@@ -9,7 +9,7 @@
 from typing_extensions import Self
 
 from hermes.model.types import ld_dict
-from hermes.model.types.ld_container import PYTHONIZED_LD_CONTAINER
+from hermes.model.types.ld_container import NATIVE_LD_CONTAINER
 from hermes.model.types.ld_context import ALL_CONTEXTS
 from hermes.model.types.pyld_util import bundled_loader
 
@@ -25,14 +25,14 @@ class SoftwareMetadata(ld_dict):
 
     def __init__(
         self: Self,
-        data: Union[dict[str, PYTHONIZED_LD_CONTAINER], None] = None,
+        data: Union[dict[str, NATIVE_LD_CONTAINER], None] = None,
         extra_vocabs: Union[dict[str, str], None] = None
     ) -> None:
         """
         Create a new instance of an SoftwareMetadata.
 
         Args:
-            data (dict[str, PYTHONIZED_LD_CONTAINER] | None): The data the SoftwareMetadata object starts out with.
+            data (dict[str, NATIVE_LD_CONTAINER] | None): The data the SoftwareMetadata object starts out with.
             extra_vocabs (dict[str, str] | None): Extra JSON_LD context for the object.
 
         Returns:

src/hermes/model/merge/container.py

@@ -24,28 +24,28 @@
 class _ld_merge_container:
     """
     Abstract base class for ld_merge_dict and ld_merge_list,
-    providing the merge containers with an override of :meth:`ld_container._to_python`.
+    providing the merge containers with an override of :meth:`ld_container._to_native_python`.
     See also :class:`ld_dict`, :class:`ld_list` and :class:`ld_container`.
     """
 
-    def _to_python(
+    def _to_native_python(
         self: Self,
         full_iri: str,
         ld_value: Union[EXPANDED_JSON_LD_VALUE, dict[str, EXPANDED_JSON_LD_VALUE], list[str], str]
     ) -> Union["ld_merge_dict", "ld_merge_list", BASIC_TYPE, TIME_TYPE]:
         """
-        Returns a pythonized version of ``ld_value`` pretending the value is in ``self`` and ``full_iri`` its key.
+        Returns a native python version of ``ld_value`` pretending the value is in ``self`` and ``full_iri`` its key.
 
         Args:
             full_iri (str): The expanded iri of the key of ``ld_value`` / ``self`` (later if self is not a dictionary).
             ld_value (EXPANDED_JSON_LD_VALUE | dict[str, EXPANDED_JSON_LD_VALUE] | list[str] | str):
-                The value thats pythonized value is requested. ``ld_value`` has to be valid expanded JSON-LD if it
+                The value thats native python value is requested. ``ld_value`` has to be valid expanded JSON-LD if it
                 was embeded in ``self._data``.
 
         Returns:
-            ld_merge_dict | ld_merge_list | BASIC_TYPE | TIME_TYPE: The pythonized value of ``ld_value``.
+            ld_merge_dict | ld_merge_list | BASIC_TYPE | TIME_TYPE: The native python value of ``ld_value``.
         """
-        value = super()._to_python(full_iri, ld_value)
+        value = super()._to_native_python(full_iri, ld_value)
         # replace ld_dicts with ld_merge_dicts
         if isinstance(value, ld_dict) and not isinstance(value, ld_merge_dict):
             value = ld_merge_dict(

src/hermes/model/types/__init__.py

@@ -19,7 +19,7 @@
     (ld_list.is_ld_list, {"ld_container": ld_list}),
     (lambda c: isinstance(c, list), {"ld_container": ld_list}),
 
-    # pythonize items from lists (expanded set is already handled above)
+    # convert items from lists (expanded set is already handled above) to native python
     (ld_container.is_typed_json_value, {"python": lambda c, **kw: ld_container.typed_ld_to_py([c], **kw)}),
     (ld_container.is_json_value, {"python": lambda c, **_: c["@value"]}),
     (ld_list.is_container, {"ld_container": lambda c, **kw: ld_list([c], **kw)}),
@@ -28,8 +28,8 @@
 ]
 """
 A list of tuples each containing a function to check if the conversion function (the second item in the tuple which
-converts the given object into a JSON_LD represented by an ld_container) is applicable for a given pythonized expanded
-JSON_LD value.
+converts the given object into a JSON_LD represented by an ld_container) is applicable for a given expanded JSON_LD
+value (given in native its native python version).
 """
 
 

src/hermes/model/types/ld_container.py

@@ -40,11 +40,11 @@
     dict[str, Union["JSON_LD_VALUE", BASIC_TYPE, TIME_TYPE, "ld_dict", "ld_list"]],
 ]
 """ Type description of valid JSON_LD objects that are partially represented by ld_containers """
-PYTHONIZED_LD_CONTAINER: TypeAlias = Union[
-    list[Union["PYTHONIZED_LD_CONTAINER", BASIC_TYPE, TIME_TYPE]],
-    dict[str, Union["PYTHONIZED_LD_CONTAINER", BASIC_TYPE, TIME_TYPE]],
+NATIVE_LD_CONTAINER: TypeAlias = Union[
+    list[Union["NATIVE_LD_CONTAINER", BASIC_TYPE, TIME_TYPE]],
+    dict[str, Union["NATIVE_LD_CONTAINER", BASIC_TYPE, TIME_TYPE]],
 ]
-""" Type description of the pythonized from of ld_containers (i.e. if the ld_container(s) is/ are replaced). """
+""" Type description of the native python version of ld_containers (i.e. if the ld_container(s) is/ are replaced). """
 
 
 class ld_container:
@@ -147,21 +147,22 @@ def ld_value(self: Self) -> EXPANDED_JSON_LD_VALUE:
         """
         return self._data
 
-    def _to_python(
+    def _to_native_python(
         self: Self,
         full_iri: str,
         ld_value: Union[EXPANDED_JSON_LD_VALUE, dict[str, EXPANDED_JSON_LD_VALUE], list[str], str]
     ) -> Union["ld_container", BASIC_TYPE, TIME_TYPE]:
         """
-        Returns a pythonized version of the given value pretending the value is in self and full_iri its key.
+        Returns a native python version of the given value pretending the value is in self and full_iri its key.
 
         Args:
             full_iri (str): The expanded iri of the key of ld_value / self (later if self is not a dictionary).
             ld_value (EXPANDED_JSON_LD_VALUE | dict[str, EXPANDED_JSON_LD_VALUE] | list[str] | str): The value thats
-                pythonized value is requested. ld_value has to be valid expanded JSON-LD if it were inside self._data.
+                native python value is requested.
+                ld_value has to be valid expanded JSON-LD if it were inside self._data.
 
         Returns:
-            ld_dict | ld_list | BASIC_TYPE | TIME_TYPE: The pythonized value of the ld_value.
+            ld_dict | ld_list | BASIC_TYPE | TIME_TYPE: The native python value of the ld_value.
         """
         if full_iri == "@id":
             # values of key "@id" only have to be compacted
@@ -300,7 +301,7 @@ def __str__(self: Self) -> str:
         Returns:
             (str): The representation of self.
         """
-        return str(self.to_python())
+        return str(self.to_native_python())
 
     def compact(
         self: Self, context: Optional[Union[list[Union[JSON_LD_CONTEXT_DICT, str]], JSON_LD_CONTEXT_DICT, str]] = None
@@ -319,7 +320,7 @@ def compact(
             self.ld_value, context or self.context, {"documentLoader": bundled_loader, "skipExpand": True}
         )
 
-    def to_python(self):
+    def to_native_python(self):
         raise NotImplementedError()
 
     @classmethod
@@ -451,14 +452,14 @@ def is_typed_json_value(cls: type[Self], ld_value: Any) -> bool:
     def typed_ld_to_py(cls: type[Self], data: list[dict[str, BASIC_TYPE]], **kwargs) -> Union[BASIC_TYPE, TIME_TYPE]:
         """
         Returns the value of the given expanded JSON-LD value containing a value type converted into that type.
-        Meaning the pythonized version of the JSON-LD value data is returned.
+        Meaning the native python version of the JSON-LD value data is returned.
         ld_container.is_typed_ld_value(data) must return True.
 
         Args:
-            data (list[dict[str, BASIC_TYPE]]): The value that is that is converted into its pythonized from.
+            data (list[dict[str, BASIC_TYPE]]): The value that is that is converted into its native python version.
 
         Returns:
-            BASIC_TYPE | TIME_TYPE: The pythonized version of data.
+            BASIC_TYPE | TIME_TYPE: The native python version of data.
         """
         # FIXME: #434 dates are not returned as datetime/ date/ time but as string
         ld_value = data[0]['@value']

src/hermes/model/types/ld_dict.py

@@ -15,7 +15,7 @@
     ld_container,
     JSON_LD_CONTEXT_DICT,
     EXPANDED_JSON_LD_VALUE,
-    PYTHONIZED_LD_CONTAINER,
+    NATIVE_LD_CONTAINER,
     JSON_LD_VALUE,
     TIME_TYPE,
     BASIC_TYPE,
@@ -71,17 +71,17 @@ def __init__(
 
     def __getitem__(self: Self, key: str) -> ld_list:
         """
-        Get the item with the given key in a pythonized form.\n
+        Get the item with the given key in as a ld_list.\n
         If self contains no key, value pair with the given key, then an empty list is added as its value and returned.
 
         Args:
             key (str): The key (compacted or expanded) to the item.
 
         Returns:
-            ld_list: The pythonized item at the key.
+            ld_list: The ld_list item at the key.
         """
         full_iri = self.ld_proc.expand_iri(self.active_ctx, key)
-        return self._to_python(full_iri, self.data_dict[full_iri])
+        return self._to_native_python(full_iri, self.data_dict[full_iri])
 
     def __setitem__(self: Self, key: str, value: Union[JSON_LD_VALUE, BASIC_TYPE, TIME_TYPE, ld_dict, ld_list]) -> None:
         """
@@ -262,14 +262,14 @@ def get(
         self: Self, key: str, default: Any = _NO_DEFAULT
     ) -> Union[ld_list, Any]:
         """
-        Get the item with the given key in a pythonized form using the build in get.\n
+        Get the item with the given key in as a ld_list using the build in get.\n
         If a KeyError is raised, return the default or reraise it if no default is given.
 
         Args:
             key (str): The key (compacted or expanded) to the item.
 
         Returns:
-            ld_list: The pythonized item at the key.
+            ld_list: The ld_list item at the key.
 
         Raises:
             KeyError: If :meth:`__getitem__(key)` raised a KeyError and default isn't set.
@@ -342,26 +342,26 @@ def ref(self: Self) -> dict[Literal["@id"], str]:
         """
         return {"@id": self.data_dict['@id']}
 
-    def to_python(self: Self) -> dict[str, Union[BASIC_TYPE, TIME_TYPE, PYTHONIZED_LD_CONTAINER]]:
+    def to_native_python(self: Self) -> dict[str, Union[BASIC_TYPE, TIME_TYPE, NATIVE_LD_CONTAINER]]:
         """
-        Return a fully pythonized version of this object where all ld_container are replaced by lists and dicts.
+        Return a native python version of this object where all ld_container are replaced by lists and dicts.
 
         Returns:
-            dict[str, BASIC_TYPE | TIME_TYPE | PYTHONIZED_LD_CONTAINER]: The fully pythonized version of self.
+            dict[str, BASIC_TYPE | TIME_TYPE | NATIVE_LD_CONTAINER]: The native python version of self.
         """
         res = {}
         for key in self.compact_keys():
             value = self[key]
             if isinstance(value, ld_container):
-                value = value.to_python()
+                value = value.to_native_python()
             res[key] = value
         return res
 
     # FIXME: Allow from_dict to handle dicts containing ld_dicts and ld_lists
     @classmethod
     def from_dict(
         cls: type[Self],
-        value: dict[str, PYTHONIZED_LD_CONTAINER],
+        value: dict[str, NATIVE_LD_CONTAINER],
         *,
         parent: Optional[Union[ld_dict, ld_list]] = None,
         key: Optional[str] = None,
@@ -373,7 +373,7 @@ def from_dict(
         Uses the expansion of the JSON-LD Processor and not the one of ld_container.
 
         Args:
-            value (dict[str, PYTHONIZED_LD_CONTAINER]): The dict of values the ld_dict should be created from.
+            value (dict[str, NATIVE_LD_CONTAINER]): The dict of values the ld_dict should be created from.
             parent (ld_dict | ld_list | None): The parent container of the new ld_list.
             key (str | None): The key into the inner most parent container representing a dict of the new ld_list.
             context (str | JSON_LD_CONTEXT_DICT | list[str | JSON_LD_CONTEXT_DICT] | None):

src/hermes/model/types/ld_list.py

@@ -18,7 +18,7 @@
     ld_container,
     JSON_LD_CONTEXT_DICT,
     EXPANDED_JSON_LD_VALUE,
-    PYTHONIZED_LD_CONTAINER,
+    NATIVE_LD_CONTAINER,
     JSON_LD_VALUE,
     TIME_TYPE,
     BASIC_TYPE,
@@ -100,21 +100,21 @@ def __getitem__(
         self: Self, index: Union[int, slice]
     ) -> Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list, list[Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list]]]:
         """
-        Get the item(s) at position index in a pythonized form.
+        Get the item(s) at position index in their native python version.
 
         Args:
             index (int | slice): The positon(s) from which the item(s) is/ are taken.
 
         Returns:
             BASIC_TYPE | TIME_TYPE | ld_dict | ld_list | list[BASIC_TYPE | TIME_TYPE | ld_dict | ld_list]:
-                The pythonized item(s) at index.
+                The item(s) at index in the native python version.
         """
         # handle slices by applying them to a list of indices and then getting the items at those
         if isinstance(index, slice):
             return [self[i] for i in [*range(len(self))][index]]
 
-        # get the item from the item_list and pythonize it. If necessary add the index.
-        item = self._to_python(self.key, self.item_list[index])
+        # get the item from the item_list and convert it into its native python version. If necessary add the index.
+        item = self._to_native_python(self.key, self.item_list[index])
         if isinstance(item, ld_container):
             item.index = index
         return item
@@ -181,14 +181,14 @@ def __len__(self: Self) -> int:
 
     def __iter__(self: Self) -> Generator[Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list], None, None]:
         """
-        Returns an iterator over the pythonized values contained in self.
+        Returns an iterator over the native python version of the values contained in self.
 
         Returns:
             Generator[BASIC_TYPE | TIME_TYPE | ld_dict | ld_list, None, None]: The Iterator over self's values.
         """
-        # return an Iterator over each value in self in its pythonized from
+        # return an Iterator over each value in self in its native python version
         for index, value in enumerate(self.item_list):
-            item = self._to_python(self.key, value)
+            item = self._to_native_python(self.key, value)
             # add which entry an ld_container is stored at, if item is an ld_container
             if isinstance(item, ld_container):
                 item.index = index
@@ -536,15 +536,15 @@ def extend(self: Self, value: list[Union[JSON_LD_VALUE, BASIC_TYPE, TIME_TYPE, l
         for item in value:
             self.append(item)
 
-    def to_python(self: Self) -> list[Union[BASIC_TYPE, TIME_TYPE, PYTHONIZED_LD_CONTAINER]]:
+    def to_native_python(self: Self) -> list[Union[BASIC_TYPE, TIME_TYPE, NATIVE_LD_CONTAINER]]:
         """
-        Return a fully pythonized version of this object where all ld_container are replaced by lists and dicts.
+        Return a native python version of this object where all ld_container are replaced by lists and dicts.
 
         Returns:
-            list[BASIC_TYPE | TIME_TYPE | PYTHONIZED_LD_CONTAINER]: The fully pythonized version of self.
+            list[BASIC_TYPE | TIME_TYPE | NATIVE_LD_CONTAINER]: The native python version of self.
         """
         return [
-            item.to_python() if isinstance(item, ld_container) else item
+            item.to_native_python() if isinstance(item, ld_container) else item
             for item in self
         ]