pymetadataeditor 0.1.0__py3-none-any.whl

pymetadataeditor/utils.py

@@ -0,0 +1,262 @@
+from typing import Annotated, Any, Dict, List, Optional, Type, Union, get_args, get_origin
+
+from metadataschemas.utils.utils import is_list_annotation, is_optional_annotation, is_optional_list
+from pydantic import BaseModel, Field
+
+
+def validate_json_patches(patches):
+    """
+    Validates a list of JSON patches according to the JSON Patch specification.
+
+    Args:
+        patches (list): A list of JSON patch dictionaries.
+
+    Returns:
+        list: The validated patches with corrected paths if necessary.
+
+    Raises:
+        ValueError: If a patch is invalid or contains an error.
+    """
+    valid_ops = {"add", "remove", "replace", "move", "copy", "test"}
+    validated_patches = []
+
+    for patch in patches:
+        if not isinstance(patch, dict):
+            raise ValueError(f"Invalid patch format: {patch}. Each patch must be a dictionary.")
+
+        op = patch.get("op")
+        path = patch.get("path")
+
+        if op not in valid_ops:
+            raise ValueError(f"Invalid operation '{op}'. Valid operations are {valid_ops}.")
+
+        if not isinstance(path, str):
+            raise ValueError(f"Invalid path: {path}. Path must be a string.")
+
+        if not path.startswith("/"):
+            path = "/" + path
+
+        # Additional checks for specific operations
+        if op in {"add", "replace", "test"} and "value" not in patch:
+            raise ValueError(f"Operation '{op}' requires a 'value' field.")
+
+        if op in {"move", "copy"} and "from" not in patch:
+            raise ValueError(f"Operation '{op}' requires a 'from' field.")
+
+        validated_patches.append({**patch, "path": path})
+
+    return validated_patches
+
+
+def remove_empty_from_dict(old_dict: Dict) -> Dict:
+    """Helper function for removing entries from dictionaries that look like:
+    [{'name': ''}]
+    """
+    new_dict = {}
+    for k, v in old_dict.items():
+        if v is None:
+            continue
+        if isinstance(v, str):
+            if v != "":
+                new_dict[k] = v
+        elif isinstance(v, dict):
+            new_sub_dict = remove_empty_from_dict(v)
+            if len(new_sub_dict) > 0:
+                new_dict[k] = new_sub_dict
+        elif isinstance(v, list):
+            new_list = remove_empty_from_list(v)
+            if len(new_list) > 0:
+                new_dict[k] = new_list
+        else:
+            new_dict[k] = v
+    return new_dict
+
+
+def remove_empty_from_list(v):
+    new_list = []
+    for elem in v:
+        if elem is None:
+            continue
+        elif isinstance(elem, dict):
+            new_elem = remove_empty_from_dict(elem)
+            if len(new_elem) > 0:
+                new_list.append(new_elem)
+        elif isinstance(elem, str):
+            if elem != "":
+                new_list.append(elem)
+        elif isinstance(elem, list):
+            new_elem = remove_empty_from_list(elem)
+            if len(new_elem) > 0:
+                new_list.append(new_elem)
+        else:
+            new_list.append(elem)
+    return new_list
+
+
+# def strip_model_rules(original_model: Type[BaseModel]) -> Type[BaseModel]:
+#     """
+#     Create a copy of a Pydantic model class (and its nested models) with validation rules stripped,
+#     but retaining titles and descriptions.
+#     """
+#     # Process fields
+#     stripped_fields = {}
+#     annotations = {}
+
+#     for name, field in original_model.model_fields.items():
+#         annotation = field.annotation
+#         default_value = field.default
+
+#         # Prepare metadata to retain title and description
+#         extra_kwargs = {}
+#         if field.title:
+#             extra_kwargs["title"] = field.title
+#         if field.description:
+#             extra_kwargs["description"] = field.description
+
+#         # Check if the annotation refers to another Pydantic model
+#         if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+#             # Recursively process the nested model
+#             stripped_sub_model = strip_model_rules(annotation)
+#             stripped_fields[name] = (
+#                 stripped_sub_model,
+#                 Field(default=default_value, **extra_kwargs),
+#             )
+#         # Handle lists of models
+#         elif get_origin(annotation) is list or get_origin(annotation) is List:
+#             item_type = get_args(annotation)[0]
+#             if isinstance(item_type, type) and issubclass(item_type, BaseModel):
+#                 # Recursively process the nested model
+#                 stripped_item_type = strip_model_rules(item_type)
+#                 stripped_fields[name] = (
+#                     List[stripped_item_type],
+#                     Field(default=default_value, **extra_kwargs),
+#                 )
+#             else:
+#                 # Leave other types untouched
+#                 stripped_fields[name] = (annotation, Field(default=default_value, **extra_kwargs))
+#         else:
+#             # For non-model fields, just copy the type, default value, and metadata
+#             stripped_fields[name] = (annotation, Field(default=default_value, **extra_kwargs))
+
+#         # Update annotations
+#         annotations[name] = stripped_fields[name][0]
+
+#     # Create the new stripped model
+#     new_model = type(
+#         f"{original_model.__name__}",
+#         (SchemaBaseModel,),
+#         {"__annotations__": annotations, **{name: field[1] for name, field in stripped_fields.items()}},
+#     )
+
+#     return new_model
+
+
+def strip_constraints_from_annotated(annotation: Any) -> Any:
+    """
+    Strip constraints from Annotated types, Optional, List, and combinations,
+    while preserving the base type.
+    """
+    # # Handle Annotated types, e.g., Annotated[str, constr(min_length=1)]
+    # if get_origin(annotation) is Annotated:
+    #     base_type = get_args(annotation)[0]
+    #     return base_type
+
+    # # Handle Optional (Union[Type, None])
+    # if get_origin(annotation) is Union:
+    #     args = get_args(annotation)
+    #     if NoneType in args:
+    #         # Get the other type in Union and return it
+    #         other_type = [arg for arg in args if arg is not None][0]
+    #         return strip_constraints_from_annotated(other_type)
+
+    # # Handle List and List of models
+    # if get_origin(annotation) is List:
+    #     item_type = get_args(annotation)[0]
+    #     return List[strip_constraints_from_annotated(item_type)]
+
+    if is_optional_list(annotation):
+        inner_annotation = get_args(get_args(annotation)[0])[0]
+        if get_origin(inner_annotation) is Annotated:
+            return Optional[List[get_args(inner_annotation)[0]]]
+    elif is_optional_annotation(annotation):
+        inner_annotation = get_args(annotation)[0]
+        if get_origin(inner_annotation) is Annotated:
+            return Optional[get_args(inner_annotation)[0]]
+    elif is_list_annotation(annotation):
+        inner_annotation = get_args(annotation)[0]
+        if get_origin(inner_annotation) is Annotated:
+            return List[get_args(inner_annotation)[0]]
+    elif get_origin(annotation) is Annotated:
+        return get_args(annotation)[0]
+
+    # If it's not a generic type or Annotated, return the original annotation
+    return annotation
+
+
+def strip_model_rules(original_model: Type[BaseModel]) -> Type[BaseModel]:
+    """
+    Create a copy of a Pydantic model class (and its nested models) with validation rules stripped,
+    but retaining titles and descriptions. Handles Annotated types like StringConstraints.
+    """
+    stripped_fields = {}
+    annotations = {}
+
+    for name, field in original_model.model_fields.items():
+        annotation = field.annotation
+        default_value = field.default
+
+        # Prepare metadata to retain title and description
+        extra_kwargs = {}
+        if field.title:
+            extra_kwargs["title"] = field.title
+        if field.description:
+            extra_kwargs["description"] = field.description
+
+        # Handle Annotated types (e.g., Annotated[str, StringConstraints])
+        annotation = strip_constraints_from_annotated(annotation)
+
+        # Check if the annotation refers to another Pydantic model
+        if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+            # Recursively process the nested model
+            stripped_sub_model = strip_model_rules(annotation)
+            stripped_fields[name] = (
+                stripped_sub_model,
+                Field(default=default_value, **extra_kwargs),
+            )
+        # Handle lists of models
+        elif get_origin(annotation) is list or get_origin(annotation) is List:
+            item_type = get_args(annotation)[0]
+            if isinstance(item_type, type) and issubclass(item_type, BaseModel):
+                # Recursively process the nested model
+                stripped_item_type = strip_model_rules(item_type)
+                stripped_fields[name] = (
+                    List[stripped_item_type],
+                    Field(default=default_value, **extra_kwargs),
+                )
+            else:
+                # Leave other types untouched
+                stripped_fields[name] = (annotation, Field(default=default_value, **extra_kwargs))
+        # Handle Union types with Annotated or nested models
+        elif get_origin(annotation) is Union:
+            stripped_union_args = tuple(
+                strip_constraints_from_annotated(arg) if isinstance(arg, type) else arg for arg in get_args(annotation)
+            )
+            stripped_fields[name] = (
+                Union[stripped_union_args],
+                Field(default=default_value, **extra_kwargs),
+            )
+        else:
+            # For non-model fields, just copy the type, default value, and metadata
+            stripped_fields[name] = (annotation, Field(default=default_value, **extra_kwargs))
+
+        # Update annotations
+        annotations[name] = stripped_fields[name][0]
+
+    # Create the new stripped model
+    new_model = type(
+        f"{original_model.__name__}",
+        (BaseModel,),
+        {"__annotations__": annotations, **{name: field[1] for name, field in stripped_fields.items()}},
+    )
+
+    return new_model

pymetadataeditor-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 World Bank
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pymetadataeditor-0.1.0.dist-info/METADATA

@@ -0,0 +1,333 @@
+Metadata-Version: 2.1
+Name: pymetadataeditor
+Version: 0.1.0
+Summary: Metadata editor client for python
+License: MIT
+Author: Gordon Blackadder
+Author-email: gblackadder@worldbank.org
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: markitdown (>=0.0.1a3,<0.0.2)
+Requires-Dist: metadataschemas (>=0.1.1,<0.2.0)
+Requires-Dist: openai (>=1.59.4,<2.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: pydantic (>=2.7.4,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
+Requires-Dist: urllib3 (>=2.2.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+# pyMetadataEditor
+
+A tool connected to Metadata Editor for creating, editing and managing metadata for microdata, indicators, geospatial data, documents, scripts, images and videos.
+
+# How to use pyMetadataEditor
+
+
+```python
+from pymetadataeditor import MetadataEditor
+import os
+```
+
+
+
+```python
+your_api_key = os.getenv("API_KEY")
+api_url = os.getenv("API_URL")
+me = MetadataEditor(api_url=api_url, api_key=your_api_key, verify_ssl=False)
+```
+
+## Listing your projects
+
+
+```python
+me.list_projects(limit=8)
+```
+
+<div>
+<style scoped>
+    .dataframe tbody tr th:only-of-type {
+        vertical-align: middle;
+    }
+
+    .dataframe tbody tr th {
+        vertical-align: top;
+    }
+
+    .dataframe thead th {
+        text-align: right;
+    }
+</style>
+<table border="1" class="dataframe">
+  <thead>
+    <tr style="text-align: right;">
+      <th></th>
+      <th>type</th>
+      <th>idno</th>
+      <th>study_idno</th>
+      <th>title</th>
+      <th>abbreviation</th>
+      <th>nation</th>
+      <th>year_start</th>
+      <th>year_end</th>
+    </tr>
+    <tr>
+      <th>id</th>
+      <th></th>
+      <th></th>
+      <th></th>
+      <th></th>
+      <th></th>
+      <th></th>
+      <th></th>
+      <th></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th>1003</th>
+      <td>document</td>
+      <td>12345</td>
+      <td>DOC_001</td>
+      <td>Sample Document 1</td>
+      <td>SD1</td>
+      <td>Example Nation</td>
+      <td>2020</td>
+      <td>2025</td>
+    </tr>
+    <tr>
+      <th>1002</th>
+      <td>survey</td>
+      <td>67890</td>
+      <td>SURVEY_002</td>
+      <td>Sample Survey 2</td>
+      <td>SS2</td>
+      <td>Example Nation</td>
+      <td>2019</td>
+      <td>2024</td>
+    </tr>
+    <tr>
+      <th>1001</th>
+      <td>timeseries</td>
+      <td>54321</td>
+      <td>TS_003</td>
+      <td>Time Series 3</td>
+      <td>TS3</td>
+      <td>Another Nation</td>
+      <td>2021</td>
+      <td>2026</td>
+    </tr>
+  </tbody>
+</table>
+</div>
+
+
+
+
+## Creating a new indicator project
+
+
+```python
+demo_name = "GB20241030_demo"
+```
+
+
+```python
+series_description = {
+                        "idno": demo_name,
+                        "doi": "V1",
+                        "name": "Version 1",
+                        "display_name": "Version 1"
+                     }
+
+indicator_id = me.create_project_log({"idno": demo_name, "series_description": series_description}, "indicator")
+```
+
+
+# Starting with outlines
+
+The metadata can be both large and hierarchical. Starting with a skeleton outline makes things easier.
+
+Outlines are available in three modes - dictionary, pydantic model and as an Excel file.
+
+## Dictionaries
+Dictionaries are created like so:
+
+
+```python
+indicator_dict = me.make_metadata_outline('indicator', output_mode='dict')
+indicator_dict
+```
+
+
+
+
+    {'metadata_information': {'title': None,
+      'idno': None,
+      'producers': [{'name': '', 'abbr': None, 'affiliation': None, 'role': None}],
+      'prod_date': None,
+      ...
+        'email': None,
+        'telephone': None,
+        'uri': None}]},
+     'tags': [{'tag': None, 'tag_group': None}]}
+
+
+## Pydantic
+
+Pydantic is a nice python library for defining and validating data schemas. An outline for the indicator schema can be created like so:
+
+
+```python
+indicator_pydantic = me.make_metadata_outline('indicator', 'pydantic')
+indicator_pydantic
+```
+
+
+giving
+
+    IHSN_INDICATOR_1-0_Template_v01_EN(metadata_information=metadata_information(title=None, idno=None, producers=[Producer(name='', abbr=None, affiliation=None, role=None)], prod_date=None, ...
+
+
+
+It can be updated using dot notation, for example:
+
+
+```python
+indicator_pydantic.metadata_information.producers[0].name = "example_producer"
+indicator_pydantic
+```
+
+
+giving
+
+    IHSN_INDICATOR_1-0_Template_v01_EN(metadata_information=metadata_information(title=None, idno=None, producers=[Producer(name='example_producer', abbr=None, affiliation=None, role=None)], prod_date=None, ...
+
+## Excel
+
+Finally, a nicely formatted Excel file can be created into which the metadata can be written, with the name of the metadata type or of the default template used as the filename if no filename is explicitly given.
+
+
+```python
+outline_filename = me.make_metadata_outline('indicator', 'excel')
+```
+
+And then read back in from Excel like so:
+
+```python
+indicator_excel = me.read_metadata_from_excel(outline_filename)
+```
+
+## Retreiving existing metadata
+
+Likewise, existing projects can be downloaded as either dictionaries, pydantic models or as excel spreadsheets.
+
+Asking for the metadata as a pydantic object
+
+```python
+demo_pydantic = me.get_project_metadata_by_id(indicator_id, 'pydantic')
+demo_pydantic
+```
+
+which gives:
+
+    IHSN_INDICATOR_1-0_Template_v01_EN(metadata_information=metadata_information(title=None, idno=None, producers=[Producer(name='', abbr=None, affiliation=None, role=None)], prod_date=None, ...
+
+# Automatic Metadata Creation and Augmentation from Sources
+
+We can use a Large Language Model to make a first draft of metadata from a source document or documents.
+
+We can create metadata from source files such as:
+- pdfs
+- word
+- excel
+- powerpoint
+- text files
+- csv
+- XML
+- ZIP files
+- Images
+
+
+
+
+```python
+docs = ["survey_records/cambodia/cambodia_lsms_basic_information_document.pdf", "survey_records/cambodia/cambodia_living_standards_measurement_study_plus_manual_english.pdf"]
+
+example = me.draft_metadata_from_files(openai_api_key=openai_key, 
+                                       files=docs, 
+                                       metadata_type_or_template_uid='microdata',
+                                       output_mode='pydantic',
+                                       metadata_producer_organization="The World Bank Group, DEC - Development Data Group"
+                                       )
+```
+
+The files are read in and sent to the LLM for processing. 
+
+    Read in survey_records/cambodia/cambodia_lsms_basic_information_document.pdf, running token count is 6373
+    Read in survey_records/cambodia/cambodia_living_standards_measurement_study_plus_manual_english.pdf, running token count is 24901
+    Sending to OpenAI, this may take a few minutes...
+
+We can then view the new metadata
+```python
+example.pretty_print()
+```
+which gives
+
+<pre style="white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace">IHSN_DDI_2-<span style="color: #800080; text-decoration-color: #800080; font-weight: bold">5_Template_v01_EN</span><span style="font-weight: bold">(</span>
+    <span style="color: #808000; text-decoration-color: #808000">doc_desc</span>=<span style="color: #800080; text-decoration-color: #800080; font-weight: bold">doc_desc</span><span style="font-weight: bold">(</span>
+        <span style="color: #808000; text-decoration-color: #808000">producers</span>=<span style="font-weight: bold">[</span>
+            <span style="color: #800080; text-decoration-color: #800080; font-weight: bold">Producer</span><span style="font-weight: bold">(</span>
+                <span style="color: #808000; text-decoration-color: #808000">name</span>=<span style="color: #008000; text-decoration-color: #008000">'The World Bank Group, DEC - Development Data Group'</span>,
+                <span style="color: #808000; text-decoration-color: #808000">abbr</span>=<span style="color: #008000; text-decoration-color: #008000">'WBG'</span>,
+                <span style="color: #808000; text-decoration-color: #808000">affiliation</span>=<span style="color: #008000; text-decoration-color: #008000">'World Bank'</span>,
+                <span style="color: #808000; text-decoration-color: #808000">role</span>=<span style="color: #008000; text-decoration-color: #008000">'Metadata producer'</span>
+            <span style="font-weight: bold">)</span>
+        <span style="font-weight: bold">]</span>,
+        <span style="color: #808000; text-decoration-color: #808000">prod_date</span>=<span style="color: #008000; text-decoration-color: #008000">'2025-01-28'</span>,
+        <span style="color: #808000; text-decoration-color: #808000">idno</span>=<span style="color: #008000; text-decoration-color: #008000">'CAMBODIA_LSMS_PLUS_2019_2020_v01_EN'</span>,
+        <span style="color: #808000; text-decoration-color: #808000">version_statement</span>=<span style="color: #800080; text-decoration-color: #800080; font-weight: bold">version_statement</span><span style="font-weight: bold">(</span>
+            <span style="color: #808000; text-decoration-color: #808000">version</span>=<span style="color: #008000; text-decoration-color: #008000">'1.0'</span>,
+            <span style="color: #808000; text-decoration-color: #808000">version_date</span>=<span style="color: #008000; text-decoration-color: #008000">'2025-01-28'</span>,
+            <span style="color: #808000; text-decoration-color: #808000">version_resp</span>=<span style="color: #008000; text-decoration-color: #008000">''</span>,
+            <span style="color: #808000; text-decoration-color: #808000">version_notes</span>=<span style="color: #008000; text-decoration-color: #008000">'First draft of the metadata for the Cambodia Living Standards Measurement Study - Plus </span>
+<span style="color: #008000; text-decoration-color: #008000">(LSMS+) 2019-20.'</span>
+        <span style="font-weight: bold">)</span>
+    <span style="font-weight: bold">)</span>,
+    ...
+
+<span style="font-weight: bold">)</span>
+</pre>
+
+
+
+
+# Contributing
+## Setting up the python environment
+
+This library uses Poetry for dependency management (https://python-poetry.org/docs/basic-usage/).
+
+In your python environment run `pip install poetry` then navigate to the pymetadataeditor folder and run `poetry install` or, if that doesn't work, try `python -m poetry install`.
+
+### Development python environment
+
+If you want to make changes to this repo then you also need to install the tools used for development but which aren't used otherwise, for example pytest.
+
+Run:
+
+`poetry install --with dev`
+`poetry run pre-commit install`
+
+### Poetry troubleshooting
+
+If you are running on Windows and see errors about numpy installation errors then it could be an issue with Windows file paths. With default settings, file paths that exceed a few hundred characters can cause installation problems. To overcome this you can either
+
+1) enable long path support in Windows (https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell#enable-long-paths-in-windows-10-version-1607-and-later)
+2) install python libraries in a folder in the current directory by running `poetry config virtualenvs.in-project true` and then running `poetry install`
+
+## Notes
+
+In keeping with World Bank Group practice, it should be noted that parts of this code base were written with the assistance of ChatGPT.

pymetadataeditor-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pymetadataeditor/__init__.py,sha256=7iI9eHfeI_mY1n1BWIsg8ydSSBZWPN_A9ctSF6SkntQ,46
+pymetadataeditor/interface.py,sha256=ZHcCtaYaTi8Sph0_GF5beAa_giR1PMdGwu5utbF_WdU,75990
+pymetadataeditor/llm_helpers.py,sha256=25HzB1aw_TDSyhOBrgmtVVkLyiQyMwR-keS_htIhXEw,4908
+pymetadataeditor/requester.py,sha256=uBzr1J3dbq-V8QUMPeE3bT1wss1A6xwACOUj31vdK6I,7151
+pymetadataeditor/templates.py,sha256=LmrOsN1PlY-Fb5SKVoOhOYKruI1nP8Ed3QxHxyIz8Nk,25984
+pymetadataeditor/utils.py,sha256=SZO04_wkP-eh1EP7X6BhrCtUGMYwOH54FfqT90Go_ic,10109
+pymetadataeditor-0.1.0.dist-info/LICENSE,sha256=FOubTO8qPACQIWI8ycK24BJGVyQ6ojw-xiymEYZthlI,1067
+pymetadataeditor-0.1.0.dist-info/METADATA,sha256=0jX_tfhz6rybNK8hQMySKuyEqmFZ0CTfH1ov97ZPe3A,11593
+pymetadataeditor-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pymetadataeditor-0.1.0.dist-info/RECORD,,

pymetadataeditor-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any