henge 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

henge/const.py

@@ -1,4 +1,4 @@
 LIBS_BY_BACKEND = {"mongo": ["pymongo", "mongodict"]}
 DELIM_ATTR = ","  # chr(30); separating attributes in an item
 DELIM_ITEM = ","  # separating items in a collection
-ITEM_TYPE = "_item_type"
+ITEM_TYPE = "_item_type"

henge/henge.py

@@ -4,7 +4,6 @@ import copy
 import hashlib
 import jsonschema
 import logging
-import logmuse
 import json
 import os
 import sys
@@ -18,10 +17,13 @@ from .const import *
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class NotFoundException(Exception):
     """Raised when a digest is not found"""
+
     def __init__(self, m):
         self.message = "{} not found in database".format(m)
+
     def __str__(self):
         return self.message
 
@@ -29,27 +31,32 @@ class NotFoundException(Exception):
 def md5(seq):
     return hashlib.md5(seq.encode()).hexdigest()
 
+
 def is_url(maybe_url):
     from urllib.parse import urlparse
-    return ' ' not in maybe_url and urlparse(maybe_url).scheme != ""
+
+    return " " not in maybe_url and urlparse(maybe_url).scheme != ""
+
 
 def read_url(url):
     _LOGGER.info("Reading URL: {}".format(url))
     from urllib.request import urlopen
     from urllib.error import HTTPError
+
     try:
         response = urlopen(url)
     except HTTPError as e:
         raise e
-    data = response.read()      # a `bytes` object
-    text = data.decode('utf-8')
+    data = response.read()  # a `bytes` object
+    text = data.decode("utf-8")
     print(text)
     return yaml.safe_load(text)
 
 
 class Henge(object):
-    def __init__(self, database, schemas, schemas_str=[], henges=None, 
-        checksum_function=md5):
+    def __init__(
+        self, database, schemas, schemas_str=[], henges=None, checksum_function=md5
+    ):
         """
         A user interface to insert and retrieve decomposable recursive unique
         identifiers (DRUIDs).
@@ -84,7 +91,9 @@ class Henge(object):
         else:
             populated_schemas = []
             if isinstance(schemas, str):
-                _LOGGER.error("The schemas should be a list. Please pass a list of schemas")
+                _LOGGER.error(
+                    "The schemas should be a list. Please pass a list of schemas"
+                )
                 schemas = [schemas]
             for schema_value in schemas:
                 if isinstance(schema_value, str):
@@ -92,8 +101,10 @@ class Henge(object):
                         populated_schemas.append(yacman.load_yaml(schema_value))
                     elif is_url(schema_value):
                         populated_schemas.append(read_url(schema_value))
-                    else :
-                        _LOGGER.error(f"Schema file not found: {schema_value}. Use schemas_str if you meant to specify a direct schema")
+                    else:
+                        _LOGGER.error(
+                            f"Schema file not found: {schema_value}. Use schemas_str if you meant to specify a direct schema"
+                        )
                         # populated_schemas.append(yaml.safe_load(schema_value))
 
             for schema_value in schemas_str:
@@ -121,7 +132,6 @@ class Henge(object):
                     self.schemas[item_type] = henge.schemas[item_type]
                     self.henges[item_type] = henge
 
-
     def retrieve(self, druid, reclimit=None, raw=False):
         """
         Retrieve an item given a digest
@@ -132,7 +142,11 @@ class Henge(object):
         :param bool raw: Return the value as a raw, henge-delimited string, instead
             of processing into a mapping. Default: False.
         """
-        item_type = self.database[druid + ITEM_TYPE]
+        try: 
+            item_type = self.database[druid + ITEM_TYPE]
+        except KeyError:
+            raise NotFoundException(druid)
+            
         digested_string = self.lookup(druid, item_type)
         reconstructed_item = json.loads(digested_string)
 
@@ -142,30 +156,39 @@ class Henge(object):
             reconstructed_item.update(external_values)
 
         schema = self.schemas[item_type]
-        
+
         if schema["type"] == "array":
-            if isinstance(reclimit, int) and reclimit == 0:  
+            if isinstance(reclimit, int) and reclimit == 0:
                 return reconstructed_item
-            if 'henge_class' in schema['items']:
-                _LOGGER.debug("Henge classed array: {}; Schema: {}".format(digested_string, schema))
+            if "henge_class" in schema["items"]:
+                _LOGGER.debug(
+                    "Henge classed array: {}; Schema: {}".format(
+                        digested_string, schema
+                    )
+                )
                 if isinstance(reclimit, int):
-                    reclimit = reclimit - 1                
+                    reclimit = reclimit - 1
                 return [self.retrieve(item, reclimit) for item in reconstructed_item]
         elif schema["type"] == "object":
-            if 'recursive' in schema:
+            if "recursive" in schema:
                 if isinstance(reclimit, int) and reclimit == 0:
-                    _LOGGER.debug("Lookup/obj/Recursive: {}; Schema: {}".format(digested_string, schema))
+                    _LOGGER.debug(
+                        "Lookup/obj/Recursive: {}; Schema: {}".format(
+                            digested_string, schema
+                        )
+                    )
                     return reconstructed_item
                 else:
                     if isinstance(reclimit, int):
                         reclimit = reclimit - 1
-                    for recursive_attr in schema['recursive']:                    
-                        if recursive_attr in reconstructed_item \
-                                and reconstructed_item[recursive_attr] != "":
+                    for recursive_attr in schema["recursive"]:
+                        if (
+                            recursive_attr in reconstructed_item
+                            and reconstructed_item[recursive_attr] != ""
+                        ):
                             reconstructed_item[recursive_attr] = self.retrieve(
-                                reconstructed_item[recursive_attr],
-                                reclimit,
-                                raw)     
+                                reconstructed_item[recursive_attr], reclimit, raw
+                            )
         return reconstructed_item
 
     def lookup(self, druid, item_type):
@@ -173,7 +196,7 @@ class Henge(object):
             henge_to_query = self.henges[item_type]
         except:
             _LOGGER.debug("No henges available for this item type")
-            raise NotFoundException(druid)        
+            raise NotFoundException(druid)
         try:
             string = henge_to_query.database[druid]
         except KeyError:
@@ -181,7 +204,6 @@ class Henge(object):
 
         return string
 
- 
     @property
     def item_types(self):
         """
@@ -217,20 +239,19 @@ class Henge(object):
             fits.
         """
 
-        
         _LOGGER.debug("Insert type: {} / Item: {}".format(item_type, item))
-        
+
         if item_type not in self.schemas.keys():
-            _LOGGER.error("I don't know about items of type '{}'. "
-                          "I know of: '{}'".format(item_type,
-                                                   list(self.schemas.keys())))
+            _LOGGER.error(
+                "I don't know about items of type '{}'. "
+                "I know of: '{}'".format(item_type, list(self.schemas.keys()))
+            )
             return False
 
         schema = self.schemas[item_type]
 
-
         flat_item = item
-        if schema['type'] == 'object':
+        if schema["type"] == "object":
             flat_item = {}
             if isinstance(reclimit, int) and reclimit == 0:
                 return self._insert_flat(item, item_type)
@@ -239,41 +260,51 @@ class Henge(object):
                     reclimit = reclimit - 1
                 for prop in item:
                     if prop in schema["properties"]:
-                        _LOGGER.debug("-Prop {}; Schema: {}".format(prop, str(schema["properties"][prop])))
+                        _LOGGER.debug(
+                            "-Prop {}; Schema: {}".format(
+                                prop, str(schema["properties"][prop])
+                            )
+                        )
                         if "recursive" in schema and prop in schema["recursive"]:
                             hclass = schema["properties"][prop]["henge_class"]
                             digest = self.insert(item[prop], hclass, reclimit)
                             flat_item[prop] = digest
-                        elif schema["properties"][prop]["type"] in ['array']:
+                        elif schema["properties"][prop]["type"] in ["array"]:
                             digest = self.insert(item[prop], "array", reclimit)
                             flat_item[prop] = digest
                         else:
                             flat_item[prop] = item[prop]
-                        _LOGGER.debug("Prop: {}; Flat item: {}".format(prop, flat_item[prop]))
+                        _LOGGER.debug(
+                            "Prop: {}; Flat item: {}".format(prop, flat_item[prop])
+                        )
                     else:
                         _LOGGER.debug(f"Prop: {prop}. Ignoring due to not in schema")
                         pass  # Ignore non-schema defined properties
 
                 # if len(flat_item) == 0:
                 #     flat_item = item
-        elif schema['type'] == 'array':
+        elif schema["type"] == "array":
             flat_item = []
-            if 'henge_class' in schema['items']:
+            if "henge_class" in schema["items"]:
                 digest = []
-                hclass = schema['items']["henge_class"]
+                hclass = schema["items"]["henge_class"]
                 if isinstance(reclimit, int) and reclimit == 0:
                     return self._insert_flat(item, item_type)
                 else:
                     if isinstance(reclimit, int):
-                        reclimit = reclimit - 1                    
-                    _LOGGER.debug("Item: {}. Pyclass: {}. hclass: {}".format(item, type(item), hclass))
+                        reclimit = reclimit - 1
+                    _LOGGER.debug(
+                        "Item: {}. Pyclass: {}. hclass: {}".format(
+                            item, type(item), hclass
+                        )
+                    )
                     for element in item:
                         digest.append(self.insert(element, hclass, reclimit))
                     flat_item = digest
             else:
                 flat_item = item
                 _LOGGER.debug("Array flat item: {}".format(flat_item))
-        else: # A primitive type with a henge class
+        else:  # A primitive type with a henge class
             _LOGGER.debug("Nice! You're using a henge-classed primitive type!")
             hclass = schema["henge_class"]
             # digest = self.insert(item, hclass)
@@ -281,12 +312,11 @@ class Henge(object):
 
         return self._insert_flat(flat_item, item_type)
 
-
     def _insert_flat(self, item, item_type=None, item_name=None):
         """
         Add flattened items (of a specified type) to the database.
 
-        Flattened items have removed all levels, so it's only attributes and 
+        Flattened items have removed all levels, so it's only attributes and
         strict values; no nesting allowed. Use the upstream insert function
         to insert full structured objects, which calls this function.
 
@@ -297,9 +327,10 @@ class Henge(object):
             fits.
         """
         if item_type not in self.schemas.keys():
-            _LOGGER.error("I don't know about items of type '{}'. "
-                          "I know of: '{}'".format(item_type,
-                                                   list(self.schemas.keys())))
+            _LOGGER.error(
+                "I don't know about items of type '{}'. "
+                "I know of: '{}'".format(item_type, list(self.schemas.keys()))
+            )
             return False
 
         # digest_version should be automatically appended to the item by the
@@ -310,11 +341,14 @@ class Henge(object):
 
         valid_schema = self.schemas[item_type]
         # Add defaults here ?
-        try: 
+        try:
             jsonschema.validate(item, valid_schema)
         except jsonschema.ValidationError as e:
-            _LOGGER.error("Not valid data. Item type: {}. Attempting to insert item: {}".
-                format(item_type, item))
+            _LOGGER.error(
+                "Not valid data. Item type: {}. Attempting to insert item: {}".format(
+                    item_type, item
+                )
+            )
             print(e)
 
             if isinstance(item, str):
@@ -322,7 +356,9 @@ class Henge(object):
                 try:
                     existing_item_type = henge_to_query.database[item + ITEM_TYPE]
                 except KeyError:
-                    _LOGGER.error("If you're trying to insert an item with druids, the sub-items must exist in the database.")
+                    _LOGGER.error(
+                        "If you're trying to insert an item with druids, the sub-items must exist in the database."
+                    )
                     # return None
                 try:
                     existing_item = henge_to_query.database[item]
@@ -330,13 +366,13 @@ class Henge(object):
                     _LOGGER.error("That item wasn't in the database.")
 
                 # if (item_type == existing_item_type):
-                    # _LOGGER.info("But wait!!! That's already here, and it's great! I'll return that!")
+                # _LOGGER.info("But wait!!! That's already here, and it's great! I'll return that!")
                 return item
 
             raise e
             return None
-        
-        _LOGGER.debug(f"item to insert: {item}")        
+
+        _LOGGER.debug(f"item to insert: {item}")
         item_inherent_split = select_inherent_properties(item, valid_schema)
         attr_string = canonical_str(item_inherent_split["inherent"])
         external_string = canonical_str(item_inherent_split["external"])
@@ -346,11 +382,16 @@ class Henge(object):
         druid = self.checksum_function(attr_string)
         self._henge_insert(druid, attr_string, item_type, external_string)
 
-        _LOGGER.debug("Inserted flat item. Digest: {} / Type: {} / Item: {}".format(
-            druid, item_type, item))
+        _LOGGER.debug(
+            "Inserted flat item. Digest: {} / Type: {} / Item: {}".format(
+                druid, item_type, item
+            )
+        )
         return druid
 
-    def _henge_insert(self, druid, string, item_type, external_string, digest_version=None):
+    def _henge_insert(
+        self, druid, string, item_type, external_string, digest_version=None
+    ):
         """
         Inserts an item into the database, with henge-metadata slots for item
         type and digest version.
@@ -392,7 +433,7 @@ class Henge(object):
                 except (KeyError, AttributeError):
                     pass
         except AttributeError as e:
-            _LOGGER.warn(f"Error trying to iterate over database items: {e}")                   
+            _LOGGER.warn(f"Error trying to iterate over database items: {e}")
 
     def show(self):
         """
@@ -401,7 +442,6 @@ class Henge(object):
         for k, v in self.database.items():
             print(k, v)
 
-
     def __repr__(self):
         repr = "Henge object. Item types: " + ",".join(self.item_types)
         return repr
@@ -413,68 +453,74 @@ def split_schema(schema, name=None):
     """
     slist = {}
     # base case
-    if schema['type'] not in ['object', 'array']:
+    if schema["type"] not in ["object", "array"]:
         _LOGGER.debug(schema)
         if name:
             slist[name] = schema
-        elif 'henge_class' in schema:
-            slist[schema['henge_class']] = schema
+        elif "henge_class" in schema:
+            slist[schema["henge_class"]] = schema
         _LOGGER.debug("Returning slist: {}".format(str(slist)))
         return slist
-    elif schema['type'] == 'object':
+    elif schema["type"] == "object":
         recursive_properties = []
-        if 'henge_class' in schema:
+        if "henge_class" in schema:
             schema_copy = copy.deepcopy(schema)
-            _LOGGER.debug("adding " + str(schema_copy['henge_class']))
-            henge_class = schema_copy['henge_class']
+            _LOGGER.debug("adding " + str(schema_copy["henge_class"]))
+            henge_class = schema_copy["henge_class"]
             # del schema_copy['henge_class']
-            for p in schema_copy['properties']:
+            for p in schema_copy["properties"]:
                 hclass = None
-                if 'henge_class' in schema_copy['properties'][p]:
-                    hclass = schema_copy['properties'][p]['henge_class']
+                if "henge_class" in schema_copy["properties"][p]:
+                    hclass = schema_copy["properties"][p]["henge_class"]
                     recursive_properties.append(p)
-                if schema_copy['properties'][p]['type'] in ['object']:
+                if schema_copy["properties"][p]["type"] in ["object"]:
                     # recursive_properties.append(p)
-                    schema_copy['properties'][p] = {'type': "string"}
+                    schema_copy["properties"][p] = {"type": "string"}
                     if hclass:
-                        schema_copy['properties'][p]['henge_class'] = hclass
-                if schema_copy['properties'][p]['type'] in ["array"]:
+                        schema_copy["properties"][p]["henge_class"] = hclass
+                if schema_copy["properties"][p]["type"] in ["array"]:
                     # recursive_properties.append(p)
-                    schema_copy['properties'][p] = {'type': "string"}
+                    if schema_copy["properties"][p]["items"]["type"] == "integer":
+                        schema_copy["properties"][p] = {"type": "string"}
+                    else:
+                        schema_copy["properties"][p] = {"type": "string"}
                     if hclass:
-                        schema_copy['properties'][p]['henge_class'] = hclass
+                        schema_copy["properties"][p]["henge_class"] = hclass
                     else:
-                        schema_copy['properties'][p]['henge_class'] = "array"
+                        schema_copy["properties"][p]["henge_class"] = "strarray"
                     # schema_copy['properties'][p]['type'] = "string"
             # del schema_copy['properties']
-            _LOGGER.debug("Adding recursive properties: {}".format(recursive_properties))
-            schema_copy['recursive'] = recursive_properties
+            _LOGGER.debug(
+                "Adding recursive properties: {}".format(recursive_properties)
+            )
+            schema_copy["recursive"] = recursive_properties
             slist[henge_class] = schema_copy
 
-        for p in schema['properties']:
+        for p in schema["properties"]:
             # if schema['properties'][p]['type'] in ['object', 'array']:
-            #     recursive_properties.append(p)            
-            schema_sub = schema['properties'][p]
+            #     recursive_properties.append(p)
+            schema_sub = schema["properties"][p]
             _LOGGER.debug("checking property:" + p)
-            slist.update(split_schema(schema['properties'][p]))
-    elif schema['type'] == 'array':
+            slist.update(split_schema(schema["properties"][p]))
+    elif schema["type"] == "array":
         _LOGGER.debug("found array")
         _LOGGER.debug(schema)
-        if 'henge_class' in schema:
+        if "henge_class" in schema:
             schema_copy = copy.deepcopy(schema)
-            _LOGGER.debug("adding " + str(schema['henge_class']))
-            henge_class = schema_copy['henge_class']
+            _LOGGER.debug("adding " + str(schema["henge_class"]))
+            henge_class = schema_copy["henge_class"]
             # del schema_copy['henge_class']
-            schema_copy['items'] = {'type': "string"}
-            if 'recursive' in schema_copy and schema_copy['recursive']:
-                schema_copy['items']['recursive'] = True
-            if 'henge_class' in schema['items']:
-                schema_copy['items']['henge_class'] = schema['items']['henge_class']
+            if schema_copy["items"]["type"] != "integer":
+                schema_copy["items"] = {"type": "string"}
+            if "recursive" in schema_copy and schema_copy["recursive"]:
+                schema_copy["items"]["recursive"] = True
+            if "henge_class" in schema["items"]:
+                schema_copy["items"]["henge_class"] = schema["items"]["henge_class"]
             # schema_copy['items']['type'] = "string"
             # if 'properties' in schema_copy['items']:
             #     del schema_copy['items']['properties']
             slist[henge_class] = schema_copy
-            schema_sub = schema['items']
+            schema_sub = schema["items"]
             slist.update(split_schema(schema_sub))
         else:
             _LOGGER.debug("Classless array")
@@ -486,8 +532,11 @@ def split_schema(schema, name=None):
 
 
 def canonical_str(item: dict) -> str:
-    """ Convert a dict into a canonical string representation """
-    return json.dumps(item, separators=(',', ':'), ensure_ascii=False, allow_nan=False, sort_keys=True) 
+    """Convert a dict into a canonical string representation"""
+    return json.dumps(
+        item, separators=(",", ":"), ensure_ascii=False, allow_nan=False, sort_keys=True
+    )
+
 
 def select_inherent_properties(item: dict, schema: dict) -> dict:
     if schema["type"] == "object":
@@ -503,25 +552,25 @@ def select_inherent_properties(item: dict, schema: dict) -> dict:
         return {"inherent": item, "external": None}
 
 
-
 def is_schema_recursive(schema):
     """
     Determine if a given schema has elements that need to recurse
     """
     # return 'recursive' in schema # old way
     is_recursive = False
-    if schema['type'] == "object":
-        for prop in schema['properties']:
-            if schema['properties']['prop']['type'] in ['object', 'array']:
+    if schema["type"] == "object":
+        for prop in schema["properties"]:
+            if schema["properties"]["prop"]["type"] in ["object", "array"]:
                 return True
-    if schema['type'] == "array":        
-        if schema['items']['type'] in ['object', 'array']:
+    if schema["type"] == "array":
+        if schema["items"]["type"] in ["object", "array"]:
             return True
     return False
 
 
-def connect_mongo(host='0.0.0.0', port=27017, database='henge_dict',
-                  collection='store'):
+def connect_mongo(
+    host="0.0.0.0", port=27017, database="henge_dict", collection="store"
+):
     """
     Connect to MongoDB and return the MongoDB-backed dict object
 
@@ -536,15 +585,20 @@ def connect_mongo(host='0.0.0.0', port=27017, database='henge_dict',
     """
     from importlib import import_module
     from inspect import stack
+
     for lib in LIBS_BY_BACKEND["mongo"]:
         try:
             globals()[lib] = import_module(lib)
         except ImportError:
             raise ImportError(
                 "Requirements not met. Package '{}' is required to setup "
-                "MongoDB connection. Install the package and call '{}' again.".
-                    format(lib, stack()[0][3]))
-    pymongo.Connection = lambda host, port, **kwargs: \
-        pymongo.MongoClient(host=host, port=port)
-    return mongodict.MongoDict(host=host, port=port, database=database,
-                               collection=collection)
+                "MongoDB connection. Install the package and call '{}' again.".format(
+                    lib, stack()[0][3]
+                )
+            )
+    pymongo.Connection = lambda host, port, **kwargs: pymongo.MongoClient(
+        host=host, port=port
+    )
+    return mongodict.MongoDict(
+        host=host, port=port, database=database, collection=collection
+    )

{henge-0.2.0.dist-info → henge-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: henge
-Version: 0.2.0
+Version: 0.2.1
 Summary: Storage and retrieval of object-derived, decomposable recursive unique identifiers.
 Home-page: https://databio.org
 Author: Nathan Sheffield

henge-0.2.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+henge/__init__.py,sha256=Su4ZQre-GS24y-LjiAIf57GYovLTww0hkk2fDxzMt_g,289
+henge/_version.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+henge/const.py,sha256=0t3EgqdjmKBd-zu5L8AJnGoWv0T3sAtvXf-3b62Dd-Y,194
+henge/deprecated.py,sha256=C8eINR2gWCiNaN2b3gbFYn8jfJ0ftJm8a_fIgVVVzXc,11248
+henge/henge.py,sha256=mvAcXefMy5r8XcgRe9XXPH5uuXdyL9-sXRYWLNp_fos,23454
+henge-0.2.1.dist-info/LICENSE.txt,sha256=oB6ZGDa4kcznznJKJsLLFFcOZyi8Y6e2Jv0rJozgp-I,1269
+henge-0.2.1.dist-info/METADATA,sha256=zW6QW4rlOKOpkymjUGkvlMRhbdXZQU_7YvTx3WM2ap8,1270
+henge-0.2.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+henge-0.2.1.dist-info/entry_points.txt,sha256=c2OKgrH1a5Cx2osbUFSe9NFK8CbN82lPPsi4wry77_M,61
+henge-0.2.1.dist-info/top_level.txt,sha256=QyovlLuKhhKP1r8bMVmxLdke9F6PZFIN7VlkzvB0xIQ,6
+henge-0.2.1.dist-info/RECORD,,

henge-0.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-henge/__init__.py,sha256=Su4ZQre-GS24y-LjiAIf57GYovLTww0hkk2fDxzMt_g,289
-henge/_version.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
-henge/const.py,sha256=BW_CMh8eU7QR8umjZA3Th3uNHZNi7jmbDp9J_uHg5to,193
-henge/deprecated.py,sha256=C8eINR2gWCiNaN2b3gbFYn8jfJ0ftJm8a_fIgVVVzXc,11248
-henge/henge.py,sha256=Cq_a7EVF519yq2Sj_QGE6GvWyJkaIITvJZ6hvblX-GU,22577
-henge-0.2.0.dist-info/LICENSE.txt,sha256=oB6ZGDa4kcznznJKJsLLFFcOZyi8Y6e2Jv0rJozgp-I,1269
-henge-0.2.0.dist-info/METADATA,sha256=asBCHFYvf83mH50QWSpaxmX6LEQCv7RKY0PtYq7P_6c,1270
-henge-0.2.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-henge-0.2.0.dist-info/entry_points.txt,sha256=c2OKgrH1a5Cx2osbUFSe9NFK8CbN82lPPsi4wry77_M,61
-henge-0.2.0.dist-info/top_level.txt,sha256=QyovlLuKhhKP1r8bMVmxLdke9F6PZFIN7VlkzvB0xIQ,6
-henge-0.2.0.dist-info/RECORD,,