gsaphub 0.2.0__py3-none-any.whl

gsaphub/__init__.py

@@ -0,0 +1,35 @@
+from . import (
+    clients,
+    compare,
+    delete,
+    enrich,
+    env,
+    evaluate,
+    extract,
+    filter,
+    load,
+    match,
+    merge,
+    show,
+    stats,
+    transform,
+    labels,
+)
+
+__all__ = [
+    "compare",
+    "delete",
+    "enrich",
+    "evaluate",
+    "extract",
+    "filter",
+    "load",
+    "match",
+    "merge",
+    "show",
+    "stats",
+    "transform",
+    "clients",
+    "env",
+    "labels",
+]

gsaphub/_inception_url_helper.py

@@ -0,0 +1,15 @@
+def ent_to_url(ent):
+    info = ent["inception_meta"]
+    if info.get("line_idx") is None:
+        return
+    info["annotator"] = ent["annotator"]
+    return info_to_url(info)
+
+
+def info_to_url(info):
+    url_base = "https://multiweb.gesis.org/berd-nfdi/p/"
+    url = (
+        f"{url_base}{info['project_id']}/annotate"
+        f"?3#!d={info['document_id']}&f={info['line_idx']}&u={info['annotator']}"
+    )
+    return url

gsaphub/clients.py

@@ -0,0 +1,36 @@
+from gql import Client, gql
+from gql.transport.aiohttp import AIOHTTPTransport
+
+
+async def graphql(url, email, password):
+    client = _create_graphql_client(url)
+    bearer = await _get_graphql_bearer(client, email, password)
+    client = _create_graphql_client(url, bearer)
+    return client
+
+
+def _create_graphql_client(url, bearer=None):
+    transport_params = dict(url=url)
+    if bearer is not None:
+        transport_params["headers"] = dict(Authorization=f"Bearer {bearer}")
+
+    transport = AIOHTTPTransport(**transport_params)
+    client = Client(transport=transport, fetch_schema_from_transport=True)
+    return client
+
+
+async def _get_graphql_bearer(client, email, password):
+    query_login = f"""
+        mutation login {{
+          authenticate(
+            input: {{email: "{email}", password: "{password}"}}
+          ) {{
+            clientMutationId
+            jwtToken
+          }}
+        }}"""
+    result_login = await client.execute_async(gql(query_login))
+    bearer = result_login["authenticate"]["jwtToken"]
+    if not bearer:
+        raise Exception("AuthentificationException: Wrong Password?")
+    return bearer

gsaphub/env.py

@@ -0,0 +1,24 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+class EnvPathsAccess:
+    annotations: str
+    annotations_plmarker: str
+    predictions: str
+    raw_docs: str
+
+    def __getattr__(self, name):
+        load_dotenv()
+        name_in_env = f"PATH_{name.upper()}"
+        value = os.environ.get(name_in_env)
+        if value is None:
+            raise AttributeError(
+                f"Set {name_in_env} in .env file or as environment variable."
+            )
+        return Path(value)
+
+
+paths = EnvPathsAccess()

gsaphub/labels.py

@@ -0,0 +1,386 @@
+from collections import defaultdict
+
+ALLOWED_ENTITY_TYPES = {
+    "Method",
+    "DatasetGeneric",
+    "MLModelGeneric",
+    "ReferenceLink",
+    "ModelArchitecture",
+    "Task",
+    "Dataset",
+    "MLModel",
+    "DataSource",
+    "URL",
+}
+
+GSAP_INTENTION_MAPPING = {
+    "IntentionCreation": "creation",
+    "IntentionComparison": "comparison",
+    "IntentionUsage": "usage",
+}
+
+
+GSAP_SUBTYPE_MAPPING = {
+    "Method > misc": ["Method", "Misc"],
+    "Method > ML techniques": ["Method", "MLTechnique"],
+    "Method > libraries and tools": ["Method", "Tool"],
+    "Method > ML paradigm": ["Method", "MLParadigm"],
+    "Method > evaluation techniques": ["Method", "EvaluationTechnique"],
+    "Method > data processing": ["Method", "DataPreprocessing"],
+    "Method > data collection": ["Method", "DataCollection"],
+    "ModelArchitecture>TraditionalMLTechnique": [
+        "ModelArchitecture",
+        "MLTraditionalTechnique",
+    ],
+    "ModelArchitecture>NNType": ["ModelArchitecture", "NeuralNetType"],
+    "ModelArchitecture>Component": ["ModelArchitecture", "MLModelComponent"],
+    "ModelArchitecture>MLModel": ["ModelArchitecture", "MLModel"],
+}
+
+GSAP_TYPES_WITH_SUBTYPES = defaultdict(set)
+for label, label_sub in GSAP_SUBTYPE_MAPPING.values():
+    GSAP_TYPES_WITH_SUBTYPES[label].add(label_sub)
+
+RELATION_MAPPING = {
+    ("Dataset", "isBasedOn", "Datasource"): "sourcedFrom",
+    ("DatasetGeneric", "isBasedOn", "Datasource"): "sourcedFrom",
+    # Data+ isBasedOn Method/MLModel+ : generatedWith
+    ("Dataset", "isBasedOn", "Method"): "generatedBy",
+    ("DatasetGeneric", "isBasedOn", "Method"): "generatedBy",
+    ("Dataset", "isBasedOn", "MLModel"): "generatedBy",
+    ("DatasetGeneric", "isBasedOn", "MLModel"): "generatedBy",
+    ("Dataset", "isBasedOn", "MLModelGeneric"): "generatedBy",
+    ("DatasetGeneric", "isBasedOn", "MLModelGeneric"): "generatedBy",
+    # Data+ isBasedOn Data+
+    ("Dataset", "isBasedOn", "Dataset"): "transformedFrom",
+    ("Dataset", "isBasedOn", "DatasetGeneric"): "transformedFrom",
+    ("DatasetGeneric", "isBasedOn", "Dataset"): "transformedFrom",
+    ("DatasetGeneric", "isBasedOn", "DatasetGeneric"): "transformedFrom",
+    # X hasArchitecture ModelArchitecture
+    ("ModelArchitecture", "isBasedOn", "ModelArchitecture"): "architecture",
+    ("MLModel", "isBasedOn", "ModelArchitecture"): "architecture",
+    ("MLModelGeneric", "isBasedOn", "ModelArchitecture"): "architecture",
+    ("Method", "isBasedOn", "ModelArchitecture"): "architecture",
+    # Method/MLModel+ isBasedOn Method => usedFor
+    ("Method", "isBasedOn", "Method"): "usedFor",
+    ("MLModel", "isBasedOn", "Method"): "usedFor",
+    ("MLModelGeneric", "isBasedOn", "Method"): "usedFor",
+    ("ModelArchitecture", "isBasedOn", "Method"): "usedFor",  # ??? exist?
+    # appliedOn
+    # benchmarkFor
+    ("Dataset", "appliedOn", "Task"): "benchmarkFor",
+    ("DatasetGeneric", "appliedOn", "Task"): "benchmarkFor",
+    # appliedTo
+    ("MLModel", "appliedOn", "Task"): "appliedTo",
+    ("MLModelGeneric", "appliedOn", "Task"): "appliedTo",
+    ("Method", "appliedOn", "Task"): "appliedTo",
+    ("ModelArchitecture", "appliedOn", "Task"): "appliedTo",  # ???
+    # hasProcessed
+    ("MLModel", "appliedOn", "Dataset"): "processed",
+    ("MLModel", "appliedOn", "DatasetGeneric"): "processed",
+    ("MLModelGeneric", "appliedOn", "Dataset"): "processed",
+    ("MLModelGeneric", "appliedOn", "DatasetGeneric"): "processed",
+    ("Method", "appliedOn", "Dataset"): "processed",
+    ("Method", "appliedOn", "DatasetGeneric"): "processed",
+    # Repair 2025-01 annotations
+    ("Dataset", "derivedFrom", "Dataset"): "transformedFrom",  # 11,
+}
+"""
+    ('MLModel', 'derivedFrom', 'MLModel'): 7,
+         ('MLModel', 'usedFor', 'Method'): 854,
+         ('ModelArchitecture', 'usedFor', 'Method'): 19}}
+
+         ('ModelArchitecture', 'appliedOn', 'DatasetGeneric'): 6,
+
+('Dataset', 'Unknown', 'DatasetGeneric'): 1,
+         ('Dataset', 'isBasedOn', 'ReferenceLink'): 1,
+		## Footnotes
+         ('DatasetGeneric', 'hasFootnote', 'FootnoteLink'): 2,
+         ('MLModelGeneric', 'hasFootnote', 'FootnoteLink'): 6,
+         ('MLModel', 'hasFootnote', 'FootnoteLink'): 4,
+         ('Method', 'hasFootnote', 'FootnoteLink'): 3,
+
+         ('MLModelGeneric', 'Unknown', 'Task'): 2,
+
+         ('MLModel', 'coreference', 'ModelArchitecture'): 1,
+         ('MLModel', 'isComparedTo', 'ModelArchitecture'): 1,
+         ('MLModelGeneric', 'isComparedTo', 'ModelArchitecture'): 1,
+         ('MLModelGeneric', 'isBasedOn', 'Dataset'): 1,
+         ('MLModelGeneric', 'isHyponymOf', 'MLModel'): 1,
+         ('MLModelGeneric', 'usedFor', 'Method'): 4114,
+         ('MLModelGeneric', 'versionOf', 'MLModel'): 1,
+         ('Method', 'isBasedOn', 'Dataset'): 3,
+         ('Method', 'isBasedOn', 'DatasetGeneric'): 3,
+         ('Method', 'isBasedOn', 'MLModelGeneric'): 1,
+         ('ModelArchitecture', 'coreference', 'MLModelGeneric'): 1,
+         ('ModelArchitecture', 'evaluatedOn', 'DatasetGeneric'): 1,
+"""
+
+RELATION_INVERSE = ["usedFor"]
+
+RELATION_LEFT_TO_RIGHT = ["coreference"]
+RELATIONS_FREE_TEXT = {
+    "usedFor": "is used for",
+    "citation": "has reference",
+    "evaluatedOn": "is evaluated on",
+    "coreference": "is identical to",
+    "architecture": "has architecture",
+    "trainedOn": "is trained on",
+    "isPartOf": "is part of",
+    "isHyponymOf": "is a",
+    "appliedTo": "is applied to",
+    "transformedTo": "is transformed to",
+    "isComparedTo": "is compared to",
+    "generatedBy": "is generated by",
+    "benchmarkFor": "is benchmarking",
+    "isBasedOn": "is based on",
+    "hasInstanceType": "has instances of type",
+    "sourcedFrom": "is sourced From",
+    "size": "has size",
+    "url": "can be found at",
+    "processed": "has processed",
+    "versionOf": "isVersionOf",
+}
+
+ENTITY_MAPPING = {
+    "Datasource": "DataSource",
+}
+
+SYMMETRIC_RELATIONS = ["coreference"]
+
+ALLOWED_SIGNATURES = [
+    # Attributive Relations
+    # citation
+    ["MLModel", "citation", "ReferenceLink"],
+    ["ModelArchitecture", "citation", "ReferenceLink"],
+    ["Task", "citation", "ReferenceLink"],
+    ["MLModelGeneric", "citation", "ReferenceLink"],
+    ["Method", "citation", "ReferenceLink"],
+    ["Dataset", "citation", "ReferenceLink"],
+    ["DatasetGeneric", "citation", "ReferenceLink"],
+    ["DataSource", "citation", "ReferenceLink"],
+    # url
+    ["MLModelGeneric", "url", "URL"],
+    ["Method", "url", "URL"],
+    ["DatasetGeneric", "url", "URL"],
+    ["MLModel", "url", "URL"],
+    ["Dataset", "url", "URL"],
+    ["DataSource", "url", "URL"],
+    ["ModelArchitecture", "url", "URL"],
+    #
+    # Inner Entity Group Relations
+    #
+    # isHyponymOf
+    # Model Like
+    ["MLModelGeneric", "isHyponymOf", "MLModelGeneric"],
+    ["MLModel", "isHyponymOf", "MLModelGeneric"],
+    ["Method", "isHyponymOf", "Method"],
+    ["ModelArchitecture", "isHyponymOf", "ModelArchitecture"],
+    ["MLModelGeneric", "isHyponymOf", "ModelArchitecture"],
+    ["MLModel", "isHyponymOf", "ModelArchitecture"],
+    ["ModelArchitecture", "isHyponymOf", "MLModelGeneric"],
+    ["Method", "isHyponymOf", "MLModelGeneric"],
+    # Task
+    ["Task", "isHyponymOf", "Task"],
+    # Data Like
+    ["DatasetGeneric", "isHyponymOf", "DatasetGeneric"],
+    ["Dataset", "isHyponymOf", "DatasetGeneric"],
+    ["DatasetGeneric", "isHyponymOf", "Dataset"],
+    #
+    # isPartOf
+    # Model|Method Like
+    ["MLModel", "isPartOf", "MLModelGeneric"],
+    ["ModelArchitecture", "isPartOf", "MLModelGeneric"],
+    ["MLModelGeneric", "isPartOf", "MLModelGeneric"],
+    ["ModelArchitecture", "isPartOf", "ModelArchitecture"],
+    ["MLModelGeneric", "isPartOf", "Method"],
+    ["Method", "isPartOf", "Method"],
+    # Task
+    ["Task", "isPartOf", "Task"],
+    # Data Like
+    ["Dataset", "isPartOf", "DatasetGeneric"],
+    ["DatasetGeneric", "isPartOf", "Dataset"],
+    ["DatasetGeneric", "isPartOf", "DatasetGeneric"],
+    ["Dataset", "isPartOf", "Dataset"],
+    #
+    # coreference
+    # Model Like
+    ["MLModelGeneric", "coreference", "MLModelGeneric"],
+    ["MLModelGeneric", "coreference", "MLModel"],
+    ["MLModel", "coreference", "MLModel"],
+    ["MLModel", "coreference", "MLModelGeneric"],
+    # Method Like
+    ["Method", "coreference", "Method"],
+    ["ModelArchitecture", "coreference", "ModelArchitecture"],
+    # Task
+    ["Task", "coreference", "Task"],
+    # Data Like
+    ["Dataset", "coreference", "Dataset"],
+    ["Dataset", "coreference", "DatasetGeneric"],
+    ["DatasetGeneric", "coreference", "Dataset"],
+    ["DatasetGeneric", "coreference", "DatasetGeneric"],
+    ["DataSource", "coreference", "DataSource"],
+    #
+    # isComparedTo
+    # Model|Method Like
+    ["MLModel", "isComparedTo", "MLModel"],
+    ["MLModel", "isComparedTo", "MLModelGeneric"],
+    ["MLModelGeneric", "isComparedTo", "MLModelGeneric"],
+    ["MLModelGeneric", "isComparedTo", "MLModel"],
+    ["Method", "isComparedTo", "Method"],
+    ["Method", "isComparedTo", "MLModelGeneric"],
+    ["Method", "isComparedTo", "MLModel"],
+    ["MLModel", "isComparedTo", "Method"],
+    ["MLModelGeneric", "isComparedTo", "Method"],
+    ["ModelArchitecture", "isComparedTo", "ModelArchitecture"],
+    ["ModelArchitecture", "isComparedTo", "MLModel"],
+    # Task
+    ["Task", "isComparedTo", "Task"],
+    # Data Like
+    ["DatasetGeneric", "isComparedTo", "DatasetGeneric"],
+    ["Dataset", "isComparedTo", "Dataset"],
+    ["DatasetGeneric", "isComparedTo", "Dataset"],
+    ["Dataset", "isComparedTo", "DatasetGeneric"],
+    #
+    # versionOf
+    # MLModel
+    #["MLModel", "versionOf", "MLModel"],
+    # Dataset
+    #["Dataset", "versionOf", "Dataset"],
+    #
+    # isBasedOn
+    # Model Like
+    ["MLModel", "isBasedOn", "MLModel"],
+    ["MLModel", "isBasedOn", "MLModelGeneric"],
+    ["MLModelGeneric", "isBasedOn", "MLModelGeneric"],
+    ["MLModelGeneric", "isBasedOn", "MLModel"],
+    #
+    # transformedFrom
+    # Data Like
+    ["DatasetGeneric", "transformedFrom", "DatasetGeneric"],
+    ["DatasetGeneric", "transformedFrom", "Dataset"],
+    ["Dataset", "transformedFrom", "DatasetGeneric"],
+    ["Dataset", "transformedFrom", "Dataset"],
+    #
+    # size
+    ["DatasetGeneric", "size", "DatasetGeneric"],
+    ["Dataset", "size", "DatasetGeneric"],
+    #
+    # hasInstanceType
+    # Data Like
+    ["Dataset", "hasInstanceType", "DatasetGeneric"],
+    ["DatasetGeneric", "hasInstanceType", "DatasetGeneric"],
+    #
+    # Inter Entity Group Relations
+    # ============================
+    #
+    # --------------+
+    # ==> Data Like |
+    # --------------+
+    #
+    # Method|Model Like ==> Data Like
+    # trainedOn
+    #   ---------
+    ["MLModelGeneric", "trainedOn", "DatasetGeneric"],
+    ["MLModel", "trainedOn", "DatasetGeneric"],
+    ["Method", "trainedOn", "DatasetGeneric"],
+    ["MLModelGeneric", "trainedOn", "Dataset"],
+    ["MLModel", "trainedOn", "Dataset"],
+    ["Method", "trainedOn", "Dataset"],
+    # evaluatedOn
+    #   -----------
+    ["MLModelGeneric", "evaluatedOn", "DatasetGeneric"],
+    ["MLModel", "evaluatedOn", "DatasetGeneric"],
+    ["MLModel", "evaluatedOn", "Dataset"],
+    ["MLModelGeneric", "evaluatedOn", "Dataset"],
+    ["Method", "evaluatedOn", "DatasetGeneric"],
+    ["Method", "evaluatedOn", "Dataset"],
+    # processed (former appliedOn)
+    #   ---------
+    #["Method", "processed", "DatasetGeneric"],
+    #["Method", "processed", "Dataset"],
+    #["MLModelGeneric", "processed", "DatasetGeneric"],
+    #["MLModel", "processed", "DatasetGeneric"],
+    #["MLModel", "processed", "Dataset"],
+    #
+    # ---------+
+    # ==> Task |
+    # ---------+
+    #
+    # Method|Model Like ==> Task
+    # appliedTo
+    #   ---------
+    ["ModelArchitecture", "appliedTo", "Task"],
+    ["MLModelGeneric", "appliedTo", "Task"],
+    ["MLModel", "appliedTo", "Task"],
+    ["Method", "appliedTo", "Task"],
+    #
+    # Data Like ==> Task
+    # benchmarkFor
+    #   ------------
+    ["DatasetGeneric", "benchmarkFor", "Task"],
+    ["Dataset", "benchmarkFor", "Task"],
+    #
+    # ----------------------+
+    # ==> Model|Method Like |
+    # ----------------------+
+    #
+    # Data Like ==> Method|Model Like
+    # generatedBy (former basedOn)
+    #   -----------
+    ["DatasetGeneric", "generatedBy", "Method"],
+    ["DatasetGeneric", "generatedBy", "MLModelGeneric"],
+    ["DatasetGeneric", "generatedBy", "MLModel"],
+    ["Dataset", "generatedBy", "Method"],
+    ["Dataset", "generatedBy", "MLModelGeneric"],
+    ["Dataset", "generatedBy", "MLModel"],
+    #
+    # Method ==> Model|Method Like
+    # usedFor (former invers basedOn)
+    #   -------
+    ["Method", "usedFor", "MLModelGeneric"],
+    ["Method", "usedFor", "MLModel"],
+    ["Method", "usedFor", "Method"],
+    ["Method", "usedFor", "ModelArchitecture"],
+    #
+    # Model|Method Like ==> ModelArchitecture
+    # architecture
+    #   ------------
+    ["MLModelGeneric", "architecture", "ModelArchitecture"],
+    ["MLModel", "architecture", "ModelArchitecture"],
+    ["ModelArchitecture", "architecture", "ModelArchitecture"],
+    ["Method", "architecture", "ModelArchitecture"],
+    #
+    # ---------------+
+    # ==> DataSource +
+    # ---------------+
+    #
+    # Data Like ==> DataSource
+    # sourcedFrom
+    #   -----------
+    ["DatasetGeneric", "sourcedFrom", "DataSource"],
+    ["Dataset", "sourcedFrom", "DataSource"],
+]
+ALLOWED_RELATION_TYPES = { relation_label for subject_type, relation_label, object_type in 
+                          ALLOWED_SIGNATURES }
+
+RELATION_GROUPS = {
+        "Model Design":{"architecture", "usedFor", "isBasedOn"},
+        "Task Binding":{"benchmarkFor", "appliedTo"},
+        "Data Usage":{"evaluatedOn", "trainedOn"},  #, "processed"},
+        "Data Provenance":{"generatedBy", "transformedFrom", "sourcedFrom"},
+        "Data Properties":{"size", "hasInstanceType"},
+        "Peer Relating":{
+            "coreference",
+            "isHyponymOf",
+            "isPartOf",
+            "isComparedTo",
+            # "versionOf",
+        },
+        "Referencing":{"url", "citation"},
+        "_average":{"weighted", "macro", "micro"},
+        }
+
+RELATION_LABEL_TO_GROUP = {
+    l: g_label for g_label, g in RELATION_GROUPS.items() for l in g
+}

gsaphub/text_units.py

@@ -0,0 +1,30 @@
+def text_unit_as_string(text_unit):
+    ents = text_unit["annotations"]
+    rels = text_unit["relations"]
+    text = text_unit["text"]
+    text += "/t"
+    text += relations_as_string(rels, ents, include_url=False)
+    if "url_inception" in text_unit:
+        text += f"\n\n{text_unit['url_inception']}"
+    return text
+
+
+def relations_as_string(relations, entities, include_url=True):
+    string = []
+    ents_dict = {e["id"]: e for e in entities}
+    for rel in relations:
+        subj = ents_dict.get(rel["subject_id"], {})
+        obj = ents_dict.get(rel["object_id"], {})
+        string.append(_relation_as_string(rel, subj, obj, include_url))
+    return "\n\t".join(string)
+
+
+def _relation_as_string(rel, subj, obj, include_url=True):
+    ent = subj if subj else obj
+    subs = f"[{subj.get('label', 'NIL')}: '{subj.get('text', '<no text>')}']"
+    rel = f"({rel.get('relation_label', 'NIL')})"
+    objs = f"[{obj.get('label', 'NIL')}: '{obj.get('text', '<no text>')}']"
+    rel = f"{subs} - {rel} - {objs}"
+    if ent and include_url:
+        rel += f"\n\t{ent.get('url_inception')}"
+    return rel

gsaphub-0.2.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: gsaphub
+Version: 0.2.0
+Summary: Data transfer platform from inception to graphql and filesystem
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.11.2
+Requires-Dist: gql>=3.5.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pip>=25.0.1
+Requires-Dist: pycaprio>=0.3.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: spacy>=3.8.5
+
+# Migraion tool to import exported inception annotations to postgraphile graphql backend
+
+## .env file
+ * please copy example.env to .env and add your credentials
+
+
+
+## To load the spacy model used for tokenizing to create the plmarker format:
+ * `uv run -- spacy download en_core_web_sm`

gsaphub-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+gsaphub/__init__.py,sha256=AcvWIHmVJHlEUMTDllxFIFYoEDa7_Ajhc8yjYnlVQsc,419
+gsaphub/_inception_url_helper.py,sha256=kCh0jOmYfvzkhBBm0G6YmxV3UivVmALUxzHiMlqV0sI,424
+gsaphub/clients.py,sha256=WI2-LK2cBLLKMe_qdexSUdEbB-s4gcQy1wHG4ktB_Dc,1142
+gsaphub/env.py,sha256=8Vi_HfLzYh1GugtALRmTWu83_BiHixt0kXOib4hmVK0,532
+gsaphub/labels.py,sha256=EpfVoJbydnyMEX-rIaJlsZfeps2Lnowyqag9rIs7RW0,14128
+gsaphub/text_units.py,sha256=_rJGZTjAaTNamMtwsLfhuOPZqYdkjS0znL7b_OmP1sA,1106
+gsaphub-0.2.0.dist-info/METADATA,sha256=5LJIVsVTbc-his8PN_hdbrrgEtvtEsIo3UacTQWMqX8,686
+gsaphub-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gsaphub-0.2.0.dist-info/top_level.txt,sha256=0wEYxQI0MF-5UbphdiIYN4k5UhVU6glhfBFRHHtJJdI,8
+gsaphub-0.2.0.dist-info/RECORD,,

gsaphub-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gsaphub-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gsaphub