dataknobs-structures 1.0.0__py3-none-any.whl

dataknobs_structures/__init__.py

@@ -0,0 +1,17 @@
+"""Data structures for AI knowledge bases."""
+
+from dataknobs_structures.conditional_dict import cdict
+from dataknobs_structures.document import Text, TextMetaData
+from dataknobs_structures.record_store import RecordStore
+from dataknobs_structures.tree import Tree, build_tree_from_string
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "RecordStore",
+    "Text",
+    "TextMetaData",
+    "Tree",
+    "build_tree_from_string",
+    "cdict",
+]

dataknobs_structures/conditional_dict.py

@@ -0,0 +1,65 @@
+"""Implementation of a conditional associative array (dict) using the strategy
+pattern.
+"""
+
+from collections.abc import Callable
+from typing import Any, Dict, Optional, Union, Iterable, Tuple
+
+
+class cdict(dict):
+    """A dictionary that conditionally accepts attributes and/or values.
+
+    This implementation uses the strategy pattern such that a function is
+    provided on initialization for validating items that are set. If an
+    attribute and/or value is not accepted during an add operation, the
+    set operation will fail and the key/value will be added to the "rejected"
+    property.
+    """
+
+    def __init__(self, accept_fn: Callable[[Dict, Any, Any], bool], *args: Any, **kwargs: Any) -> None:
+        """:param accept_fn: A fn(d, key, value) that returns True to accept
+        the key/value into this dict d, or False to reject.
+        """
+        super().__init__()
+        self._rejected: Dict[Any, Any] = dict()
+        self.accept_fn = accept_fn
+        # super().__init__(*args, **kwargs)
+        self.update(*args, **kwargs)
+
+    @property
+    def rejected(self) -> Dict:
+        return self._rejected
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        if self.accept_fn(self, key, value):
+            super().__setitem__(key, value)
+        else:
+            self._rejected[key] = value
+
+    def setdefault(self, key: Any, default: Any = None) -> Any:
+        rv = None
+        if key not in self:
+            if self.accept_fn(self, key, default):
+                super().__setitem__(key, default)
+                rv = default
+            else:
+                self._rejected[key] = default
+        else:
+            rv = self[key]
+        return rv
+
+    def update(self, *args: Any, **kwargs: Any) -> None:
+        # Handle positional argument if present
+        if args:
+            other = args[0]
+            if hasattr(other, "keys"):
+                # It's a mapping-like object
+                for key in other.keys():
+                    self.__setitem__(key, other[key])
+            else:
+                # It's an iterable of key-value pairs
+                for key, value in other:
+                    self.__setitem__(key, value)
+        # Handle keyword arguments
+        for key in kwargs:
+            self.__setitem__(key, kwargs[key])

dataknobs_structures/document.py

@@ -0,0 +1,83 @@
+from typing import Any
+
+# Key text metadata attributes
+TEXT_ID_ATTR = "text_id"
+TEXT_LABEL_ATTR = "text_label"
+TEXT_LABEL = "text"
+
+
+class MetaData:
+    """Container for managing and providing access to meta-data."""
+
+    def __init__(self, key_data: dict[str, Any], **kwargs: Any) -> None:
+        """
+        Initialize with the mandatory or "key" data and any additional optional
+        values.
+        """
+        self._data = key_data.copy() if key_data is not None else {}
+        if kwargs is not None:
+            self._data.update(kwargs)
+
+    @property
+    def data(self) -> dict[str, Any]:
+        """The data dictionary."""
+        return self._data
+
+    def get_value(self, attribute: str, missing: str | None = None) -> Any:
+        """
+        Get the value for the given attribute, or the "missing" value.
+
+        :param attribute: The meta-data attribute whose value to get
+        :param missing: The missing value
+        :return: The attribute's value or the missing value.
+        """
+        return self.data.get(attribute, missing)
+
+
+class TextMetaData(MetaData):
+    """Container for text meta-data."""
+
+    def __init__(self, text_id: Any, text_label: str = TEXT_LABEL, **kwargs: Any) -> None:
+        super().__init__(
+            {
+                TEXT_ID_ATTR: text_id,
+                TEXT_LABEL_ATTR: text_label,
+            },
+            **kwargs,
+        )
+
+    @property
+    def text_id(self) -> Any:
+        return self.data[TEXT_ID_ATTR]
+
+    @property
+    def text_label(self) -> str | Any:
+        return self.data[TEXT_LABEL_ATTR]
+
+
+class Text:
+    """Wrapper for a text string for analysis."""
+
+    def __init__(
+        self,
+        text: str,
+        metadata: TextMetaData | None,
+    ) -> None:
+        self._text = text
+        self._metadata = metadata if metadata is not None else TextMetaData(0, TEXT_LABEL)
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    @property
+    def text_id(self) -> Any:
+        return self.metadata.text_id
+
+    @property
+    def text_label(self) -> str:
+        return self.metadata.text_label
+
+    @property
+    def metadata(self) -> TextMetaData:
+        return self._metadata

dataknobs_structures/record_store.py

@@ -0,0 +1,83 @@
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+
+class RecordStore:
+    """Wrapper around a sequence of records represented in memory as a list of
+    dictionaries and/or as a dataframe and as a tsv file on disk.
+    """
+
+    def __init__(
+        self,
+        tsv_fpath: Optional[str],
+        df: Optional[pd.DataFrame] = None,
+        sep: str = "\t",
+    ):
+        """:param tsv_fpath: The path to the tsv file on disk. If None or
+            empty, then data will not be persisted.
+        :param df: An initial dataframe
+        :param sep: The file separator to use (if not a tab)
+        """
+        self.tsv_fpath = tsv_fpath
+        self.init_df = df
+        self.sep = sep
+        self._df: Optional[pd.DataFrame] = None
+        self._recs: List[Dict[str, Any]] = []  # Initialize as empty list, not None
+        self._init_data(df)
+
+    def _init_data(self, df: Optional[pd.DataFrame] = None) -> None:
+        """Initialize store data from the tsv file."""
+        if self.tsv_fpath is not None and os.path.exists(self.tsv_fpath):
+            self._df = pd.read_csv(self.tsv_fpath, sep=self.sep)
+        else:
+            self._df = df.copy() if df is not None else None
+        self._recs = self._build_recs_from_df()
+
+    def _build_recs_from_df(self) -> List[Dict[str, Any]]:
+        """Build records from the dataframe"""
+        if self._df is not None:
+            recs = [
+                json.loads(rec)
+                for rec in self._df.to_json(orient="records", lines=True).strip().split("\n")
+            ]
+        else:
+            recs = []
+        return recs
+
+    @property
+    def df(self) -> Optional[pd.DataFrame]:
+        """Get the records as a dataframe"""
+        if self._df is None and self._recs is not None:
+            self._df = pd.DataFrame(self._recs)
+        return self._df
+
+    @property
+    def records(self) -> List[Dict[str, Any]]:
+        """Get the records as a list of dictionaries"""
+        return self._recs or []
+
+    def clear(self) -> None:
+        """Clear the contents, starting from empty, but don't auto-"save"."""
+        self._recs.clear()
+        self._df = None
+
+    def add_rec(self, rec: Dict[str, Any]) -> None:
+        """Add the record"""
+        self._recs.append(rec)
+        self._df = None
+
+    def save(self) -> None:
+        """Save the records to disk as a tsv"""
+        if self.tsv_fpath is not None and self.df is not None:
+            self.df.to_csv(self.tsv_fpath, sep=self.sep, index=False)
+
+    def restore(self, df: Optional[pd.DataFrame] = None) -> None:
+        """Restore records from the version on disk, discarding any changes.
+        NOTE: If there is no backing file (e.g., tsv_fpath is None), then
+        restore will discard all data and restart with the given df (if not
+        None,) the init df or start anew.
+        """
+        self._init_data(df if df is not None else self.init_df)

dataknobs_structures/tree.py

@@ -0,0 +1,462 @@
+"""Implementation of a simple tree data structure."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Callable
+from typing import Any, List, Tuple, Union, Optional, Deque
+
+import graphviz
+from pyparsing import OneOrMore, nestedExpr
+
+
+class Tree:
+    """Implementation of a simple tree data structure.
+
+    Where the tree is represented as a node containing:
+      * (arbitrary) data
+      * a list of (ordered) child nodes
+      * a single (optional) parent node
+
+    And each tree node is doubly linked from parent to child(ren) and from
+    child to parent for efficient traversal both up (to parent) and down
+    (to children) the tree.
+    """
+
+    def __init__(
+        self,
+        data: Any,
+        parent: Union[Tree, Any] = None,
+        child_pos: Optional[int] = None,
+    ):
+        """Initialize a tree (node), optionally adding it to the given parent
+        at an optional child position.
+
+        :param data: The data to be contained within the node.
+        :param parent: The parent node to this node.
+        """
+        self._data = data
+        self._children: Optional[List[Tree]] = None
+        self._parent: Optional[Tree] = None
+        if parent is not None:
+            if not isinstance(parent, Tree):
+                parent = Tree(parent)
+            parent.add_child(self, child_pos)
+
+    def __repr__(self) -> str:
+        """:return: The string representation of this tree."""
+        return self.as_string(delim="  ", multiline=True)
+
+    @property
+    def data(self) -> Any:
+        """:return: This node's data."""
+        return self._data
+
+    @data.setter
+    def data(self, data: Any) -> None:
+        """:return: Set this node's data."""
+        self._data = data
+
+    @property
+    def children(self) -> Optional[List[Tree]]:
+        """:return: This node's children -- list of child nodes."""
+        return self._children
+
+    @property
+    def parent(self) -> Optional[Tree]:
+        """:return: This node's parent."""
+        return self._parent
+
+    @parent.setter
+    def parent(self, parent: Optional[Tree]) -> None:
+        """:return: Set this node's parent."""
+        self._parent = parent
+
+    @property
+    def root(self) -> Tree:
+        """:return: The root of this node's tree."""
+        root = self
+        while root.parent is not None:
+            root = root.parent
+        return root
+
+    @property
+    def sibnum(self) -> int:
+        """:return: This node's sibling number (0-based) among its parent's children"""
+        return self._parent.children.index(self) if self._parent is not None and self._parent.children is not None else 0
+
+    @property
+    def num_siblings(self) -> int:
+        """:return: Get the number of siblings (including self) of this node"""
+        return self._parent.num_children if self._parent is not None else 1
+
+    @property
+    def next_sibling(self) -> Optional[Tree]:
+        """:return: This node's next sibling (or None)"""
+        result = None
+        if self._parent and self._parent.children:
+            sibs = self._parent.children
+            nextsib = sibs.index(self) + 1
+            if nextsib < len(sibs):
+                result = sibs[nextsib]
+        return result
+
+    @property
+    def prev_sibling(self) -> Optional[Tree]:
+        """:return: This node's previous sibling (or None)"""
+        result = None
+        if self._parent and self._parent.children:
+            sibs = self._parent.children
+            prevsib = sibs.index(self) - 1
+            if prevsib >= 0:
+                result = sibs[prevsib]
+        return result
+
+    def has_children(self) -> bool:
+        """:return: Whether this node has children."""
+        return self._children is not None and len(self._children) > 0
+
+    @property
+    def num_children(self) -> int:
+        """:return: The number of children under this node."""
+        return len(self._children) if self._children is not None else 0
+
+    def has_parent(self) -> bool:
+        """:return: Whether this not has a parent.
+
+        Note that the "root" of a tree has no parent.
+        """
+        return self._parent is not None
+
+    @property
+    def depth(self) -> int:
+        """:return: The depth of this node in its tree.
+
+        Where the depth is measured as the number of "hops" from the root,
+        whose depth is 0, to children until this node is reached.
+        """
+        result = 0
+        curp = self.parent
+        while curp is not None:
+            curp = curp.parent
+            result += 1
+        return result
+
+    def add_child(self, node_or_data: Union[Tree, Any], child_pos: Optional[int] = None) -> Tree:
+        """Add a child node to this node, pruning the child from any other tree.
+
+        :param node_or_data: The node (or data for a new node) to add
+        :param child_pos: The (optional) position at which to insert the node.
+        :return: the (passed or new) child_node
+        """
+        if self._children is None:
+            self._children = []
+        if isinstance(node_or_data, Tree):
+            child = node_or_data
+            child.prune()
+            if child_pos is not None and child_pos < len(self._children) and child_pos >= 0:
+                self._children.insert(child_pos, child)
+            else:
+                self._children.append(child)
+        else:
+            child = Tree(node_or_data, self, child_pos=child_pos)
+        child.parent = self
+        return child
+
+    def add_edge(
+        self,
+        parent_node_or_data: Union[Tree, Any],
+        child_node_or_data: Union[Tree, Any],
+    ) -> Tuple[Tree, Tree]:
+        """Add the child to the parent, using an existing (matching) child or parent.
+        If the parent and child already exist, but not as parent and child, the
+        child node will be moved to be a child of the parent.
+
+        If neither the parent nor child nodes exist in this tree, the parent
+        will be added as a child of this (self) node.
+
+        :param parent_node_or_data: The parent node (or its data)
+        :param child_node_or_data: The child node (or its data)
+        :return: The (parent-node, child-node) tuple
+        """
+        parent = None
+        child = None
+
+        if isinstance(parent_node_or_data, Tree):
+            parent = parent_node_or_data
+            # if it is not in this tree ...
+            if (
+                len(
+                    self.find_nodes(lambda node: node == parent, include_self=True, only_first=True)
+                )
+                == 0
+            ):
+                # ...then add it as a child of self
+                self.add_child(parent)
+        else:
+            # can we find the data in this tree ...
+            found = self.find_nodes(
+                lambda node: node.data == parent_node_or_data, include_self=True, only_first=True
+            )
+            if len(found) > 0:
+                parent = found[0]
+            else:
+                parent = self.add_child(parent_node_or_data)
+
+        if isinstance(child_node_or_data, Tree):
+            child = parent.add_child(child_node_or_data)
+        else:
+            # can we find the data in this tree ...
+            found = self.find_nodes(
+                lambda node: node.data == child_node_or_data, include_self=True, only_first=True
+            )
+            if len(found) > 0:
+                child = parent.add_child(found[0])
+            else:
+                child = parent.add_child(child_node_or_data)
+
+        return (parent, child)
+
+    def prune(self) -> Optional[Tree]:
+        """Prune this node from its tree.
+        :return: this node's (former) parent.
+        """
+        result = self._parent
+        if self._parent is not None:
+            if self._parent.children is not None:
+                self._parent.children.remove(self)
+            self._parent = None
+        return result
+
+    def find_nodes(
+        self,
+        accept_node_fn: Callable[[Tree], bool],
+        traversal: str = "dfs",
+        include_self: bool = True,
+        only_first: bool = False,
+        highest_only: bool = False,
+    ) -> List[Tree]:
+        """Find nodes where accept_node_fn(tree) is True,
+        using a traversal of:
+          'dfs' -- depth first search
+          'bfs' -- breadth first search
+
+        :param accept_node_fn: A function returning a boolean for any Tree
+            argument; True to select the node or False to skip it
+        :param traversal: Either 'dfs' or 'bfs' for depth- or breadth-first
+        :param include_self: True to consider this node, False to start with
+            its children
+        :param only_first: True to stop after finding the first match
+        :param highest_only: True to not collect any nodes under a selected node
+        :return: The list of matching/accepted nodes
+        """
+        queue: Deque[Tree] = deque()
+        found: List[Tree] = []
+        if include_self:
+            queue.append(self)
+        elif self.children:
+            queue.extend(self.children)
+        while bool(queue):  # true while length(queue) > 0
+            item = queue.popleft()
+            if accept_node_fn(item):
+                found.append(item)
+                if only_first:
+                    break
+                elif highest_only:
+                    continue
+            if item.children:
+                if traversal == "dfs":
+                    queue.extendleft(reversed(item.children))
+                elif traversal == "bfs":
+                    queue.extend(item.children)
+        return found
+
+    def collect_terminal_nodes(
+        self, accept_node_fn: Optional[Callable[[Tree], bool]] = None, _found: Optional[List[Tree]] = None
+    ) -> List[Tree]:
+        """Collect this tree's terminal nodes.
+
+        :param accept_node_fn: Optional function to select which terminal nodes
+            to include in the result
+        :param _found: The (optional) list to which to add results
+        :return: The list of collected nodes
+        """
+        if _found is None:
+            _found = list()
+        if not self._children:
+            if accept_node_fn is None or accept_node_fn(self):
+                _found.append(self)
+        else:
+            for child in self._children:
+                child.collect_terminal_nodes(accept_node_fn=accept_node_fn, _found=_found)
+        return _found
+
+    def get_edges(
+        self,
+        traversal: str = "bfs",
+        include_self: bool = True,
+        as_data: bool = True,
+    ) -> List[Tuple[Union[Tree, Any], Union[Tree, Any]]]:
+        """Get the edges of this tree, either as Tree nodes or data.
+
+        :param traversal: Either 'dfs' or 'bfs' for depth- or breadth-first
+        :param include_self: True to include this node, False to start with
+            its children
+        :param as_data: If True, then collect node data instead of Tree nodes
+        :return: A list of (parent, child) tuples of edge nodes or data
+        """
+        queue: Deque[Tree] = deque()
+        result: List[Tuple[Union[Tree, Any], Union[Tree, Any]]] = []
+        if self.children:
+            queue.extend(self.children)
+        while bool(queue):  # true while length(queue) > 0
+            item = queue.popleft()
+            if item.parent:
+                if item.parent != self or include_self:
+                    result.append((item.parent.data, item.data) if as_data else (item.parent, item))
+            if item.children:
+                if traversal == "dfs":
+                    queue.extendleft(reversed(item.children))
+                elif traversal == "bfs":
+                    queue.extend(item.children)
+        return result
+
+    def get_path(self) -> List[Tree]:
+        """Get the nodes from the root to this node (inclusive)."""
+        path: Deque[Tree] = deque()
+        node: Optional[Tree] = self
+        while node is not None:
+            path.appendleft(node)
+            node = node.parent
+        return list(path)
+
+    def is_ancestor(self, other: Tree, self_is_ancestor: bool = False) -> bool:
+        """Determine whether this node is an ancestor to the other.
+        :param other: The potential descendant of this node
+        :param self_is_ancestor: True if this node could be considered to
+            be its own ancestor
+        :return: True if this node is an ancestor of the other
+        """
+        result = False
+        parent = other if self_is_ancestor else other.parent
+        while parent is not None:
+            if parent == self:
+                result = True
+                break
+            parent = parent.parent
+        return result
+
+    def find_deepest_common_ancestor(self, other: Optional[Tree]) -> Optional[Tree]:
+        """Find the deepest common ancestor to self and other.
+        :param other: The other node whose shared ancestor with self to find
+        :return: The deepest common ancestor to self and other, or None
+        """
+        if other is None:
+            return None
+        if self == other:
+            return self
+        result: Optional[Tree] = None
+        mypath, otherpath = self.get_path(), other.get_path()
+        mypathlen, otherpathlen = len(mypath), len(otherpath)
+        mypathidx, otherpathidx = 0, 0
+        while mypathidx < mypathlen and otherpathidx < otherpathlen:
+            mynode, othernode = mypath[mypathidx], otherpath[otherpathidx]
+            mypathidx += 1
+            otherpathidx += 1
+            if mynode != othernode:
+                break  # diverged
+            else:
+                result = mynode
+        return result
+
+    def as_string(self, delim: str = " ", multiline: bool = False) -> str:
+        """Get a string representing this tree.
+        :param delim: The (indentation) delimiter to use between node data
+        :param multiline: True to include newlines in the result
+        :param: A string representation of this tree and its descendants
+        """
+        result = ""
+        if self._children:
+            btwn = "\n" if multiline else ""
+            result = "(" + str(self.data)
+            for child in self._children:
+                d = (child.depth if multiline else 1) * delim
+                result += btwn + d + child.as_string(delim=delim, multiline=multiline)
+            result += ")"
+        else:
+            result = str(self.data)
+        return result
+
+    def get_deepest_left(self) -> Tree:
+        """:return: The terminal descendent following the left-most branches
+        of this node.
+        """
+        node = self
+        while node.has_children() and node.children is not None:
+            node = node.children[0]
+        return node
+
+    def get_deepest_right(self) -> Tree:
+        """:return: The terminal descendent following the right-most branches
+        of this node.
+        """
+        node = self
+        while node.has_children() and node.children is not None:
+            node = node.children[-1]
+        return node
+
+    def build_dot(
+        self, node_name_fn: Optional[Callable[[Tree], str]] = None, **kwargs: Any
+    ) -> graphviz.graphs.Digraph:
+        """Build a graphviz dot file for this tree, passing kwargs to
+        graphviz.Digraph.
+
+        :param node_name_fn: A function to build a graph node name string
+            from a node. Default is str(node.data).
+
+        Example Usage:
+            dot = build_dot(name='Name', format='png', node_attr={'shape': 'none'})
+            print(dot.source)  # e.g. to a .dot file
+            ipath = dot.render('/tmp/test/testimg', format='png')  # to create an image file
+            Image(filename=ipath)  # to display the image in jupyter
+        """
+        if node_name_fn is None:
+            node_name_fn = lambda n: str(n.data)
+        dot = graphviz.Digraph(**kwargs)
+        ids = dict()  # ids[node] -> id
+        for idx, node in enumerate(self.root.find_nodes(lambda _n: True, traversal="bfs")):
+            ids[node] = idx
+            dot.node(f"N_{idx:03}", node_name_fn(node))
+        for node1, node2 in self.get_edges(as_data=False):
+            idx1 = ids[node1]
+            idx2 = ids[node2]
+            dot.edge(f"N_{idx1:03}", f"N_{idx2:03}")
+        return dot
+
+
+def build_tree_from_string(from_string: str) -> Tree:
+    """Build a tree object from the given tree string, e.g., output from
+    the "Tree.as_string" method.
+    :param from_string: The tree string
+    :return: The built Tree
+    """
+    if not from_string.strip().startswith("("):
+        return Tree(from_string)
+    data = OneOrMore(nestedExpr()).parseString(from_string)
+    return build_tree_from_list(data.as_list())
+
+
+def build_tree_from_list(data: Union[Any, List]) -> Tree:
+    """Auxiliary to build_tree for recursively building nodes from a list of
+    lists.
+    :param data: The tree data as a list of lists.
+    :return: The root tree node
+    """
+    node = None
+    if isinstance(data, list) and len(data) > 0:
+        node = build_tree_from_list(data[0])
+        for cdata in data[1:]:
+            node.add_child(build_tree_from_list(cdata))
+    else:  # e.g. if isinstance(data, str):
+        node = Tree(data)
+    return node

dataknobs_structures-1.0.0.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: dataknobs-structures
+Version: 1.0.0
+Summary: Data structures for AI knowledge bases
+Author-email: Spence Koehler <KoehlerSB747@gmail.com>
+Requires-Python: >=3.10
+Requires-Dist: dataknobs-common>=1.0.0
+Requires-Dist: graphviz>=0.20.3
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pyparsing>=3.0.0
+Description-Content-Type: text/markdown
+
+# dataknobs-structures
+
+Data structures for AI knowledge bases.
+
+## Installation
+
+```bash
+pip install dataknobs-structures
+```
+
+## Features
+
+- **ConditionalDict**: Dictionary with conditional value retrieval
+- **Document**: Document representation with metadata
+- **RecordStore**: Efficient record storage and retrieval
+- **Tree**: Tree data structure with various traversal methods
+
+## Usage
+
+```python
+from dataknobs_structures import Tree, Document
+
+# Create a tree structure
+tree = Tree()
+tree.add_node("root", "Root Node")
+tree.add_node("child1", "Child 1", parent="root")
+
+# Create a document
+doc = Document(
+    content="Sample document content",
+    metadata={"author": "John Doe", "date": "2024-01-01"}
+)
+```
+
+## License
+
+See LICENSE file in the root repository.

dataknobs_structures-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+dataknobs_structures/__init__.py,sha256=4QTb5e2YVRQBIP_e-8Vq3eLJpZt3-QpEil_6s80iF-g,433
+dataknobs_structures/conditional_dict.py,sha256=h9qnhyDkTZynpAmMZz7_1XE235I9gZ0BS9eh_h14CtU,2294
+dataknobs_structures/document.py,sha256=LiQf0tyEYl0VdIGJ9vZlG2rkGWgJ867XbmrC4JshBTk,2182
+dataknobs_structures/record_store.py,sha256=uPEmusrGPaHtiZF3fWCG_LAIUYoQeKYWAOG87rLmSmw,2931
+dataknobs_structures/tree.py,sha256=13bJvCPn13YJhFcRHoYMuG217o4o3KbCdkYu-S4y4lw,17051
+dataknobs_structures-1.0.0.dist-info/METADATA,sha256=wetQ-K-I8Ldp-6CHA0zbCdXeWP5OKJjkWk5vspo2Ygo,1134
+dataknobs_structures-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dataknobs_structures-1.0.0.dist-info/RECORD,,

dataknobs_structures-1.0.0.dist-info/WHEEL

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