graph-dictlearn 0.1.0__tar.gz

graph_dictlearn-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nimendra Gunawardana
+
+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.

graph_dictlearn-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: graph_dictlearn
+Version: 0.1.0
+Summary: A set of representation learning and dictionary learning algorithms for graph data.
+Author-email: Nimendra Gnawardana <nimendraamiththa1@gmail.com>, Siyathma Wedamulla <wedamullasiyathma@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nimendra-ag/graph_dictlearn
+Project-URL: Repository, https://github.com/nimendra-ag/graph_dictlearn
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gensim==4.4.0
+Requires-Dist: joblib==1.5.3
+Requires-Dist: matplotlib==3.11.0
+Requires-Dist: networkx==3.6.1
+Requires-Dist: numpy==2.5.0
+Requires-Dist: pandas==3.0.3
+Requires-Dist: rdkit==2026.3.3
+Requires-Dist: scikit-learn==1.9.0
+Requires-Dist: scipy==1.18.0
+Requires-Dist: seaborn==0.13.2
+Dynamic: license-file
+
+# graph_dictlearn
+A set of representation learning and dictionary learning algorithms for graph data.
+
+You can use this pip package to apply dictionary learning algorithms for graph data.

graph_dictlearn-0.1.0/README.md

@@ -0,0 +1,4 @@
+# graph_dictlearn
+A set of representation learning and dictionary learning algorithms for graph data.
+
+You can use this pip package to apply dictionary learning algorithms for graph data.

graph_dictlearn-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "graph_dictlearn"
+version = "0.1.0"
+description = "A set of representation learning and dictionary learning algorithms for graph data."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.12"
+authors = [
+    {name = "Nimendra Gnawardana", email = "nimendraamiththa1@gmail.com"},
+    {name = "Siyathma Wedamulla", email = "wedamullasiyathma@gmail.com"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "gensim==4.4.0",
+    "joblib==1.5.3",
+    "matplotlib==3.11.0",
+    "networkx==3.6.1",
+    "numpy==2.5.0",
+    "pandas==3.0.3",
+    "rdkit==2026.3.3",
+    "scikit-learn==1.9.0",
+    "scipy==1.18.0",
+    "seaborn==0.13.2",
+]
+
+[project.urls]
+Homepage = "https://github.com/nimendra-ag/graph_dictlearn"
+Repository = "https://github.com/nimendra-ag/graph_dictlearn"
+
+[tool.setuptools.packages.find]
+where = ["src"]

graph_dictlearn-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

graph_dictlearn-0.1.0/src/graph_dictlearn/__init__.py

@@ -0,0 +1,8 @@
+"""A set of representation learning and dictionary learning algorithms for graph data."""
+
+from graph_dictlearn.loader.loader import SDFLoader
+from graph_dictlearn.encoders.wl import WL
+from graph_dictlearn.dict_learners.aksvd import AKSVD
+
+__all__ = ["SDFLoader", "WL", "AKSVD"]
+__version__ = "0.1.0"

graph_dictlearn-0.1.0/src/graph_dictlearn/dict_learners/__init__.py

@@ -0,0 +1,5 @@
+"""Dictionary learning implementations."""
+
+from graph_dictlearn.dict_learners.aksvd import AKSVD
+
+__all__ = ["AKSVD"]

graph_dictlearn-0.1.0/src/graph_dictlearn/dict_learners/aksvd.py

@@ -0,0 +1,30 @@
+from graph_dictlearn.dict_learners.base import DictLearner
+from graph_dictlearn.dict_learners.ksvd import ApproximateKSVD
+
+
+class AKSVD(DictLearner):
+    def __init__(
+            self,
+            dimensions: int = 16,
+            max_iter: int = 10,
+            tol: float = 1e-6,
+            n_non_zero_coefs: int = 10,
+    ):
+        super().__init__(name="AKSVD")
+        self._dictionary = None
+        self.dimensions = dimensions
+        self.max_iter = max_iter
+        self.tol = tol
+        self.n_non_zero_coefs = n_non_zero_coefs
+        self.aksvd = ApproximateKSVD(n_components=self.dimensions, max_iter=self.max_iter, tol=self.tol,
+                 transform_n_nonzero_coefs=self.n_non_zero_coefs)
+
+    def fit(self, training_graph_embeddings):
+        self._dictionary = self.aksvd.fit(training_graph_embeddings).components_
+
+        # self._embedding = self.aksvd.transform(training_graph_embeddings)
+        return self
+
+    def infer(self, infer_graph_embeddings):
+        sparse_embeddings = self.aksvd.transform(infer_graph_embeddings)
+        return sparse_embeddings

graph_dictlearn-0.1.0/src/graph_dictlearn/dict_learners/base.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+class DictLearner(ABC):
+    def __init__(self, name: str):
+        self.name = name
+
+    @abstractmethod
+    def fit(self, training_graph_embeddings):
+        pass
+
+    @abstractmethod          # ← add this decorator
+    def infer(self, infer_graph_embeddings):
+        pass

graph_dictlearn-0.1.0/src/graph_dictlearn/dict_learners/ksvd.py

@@ -0,0 +1,84 @@
+import numpy as np
+import scipy as sp
+from sklearn.linear_model import orthogonal_mp_gram
+
+
+class ApproximateKSVD():
+    def __init__(self, n_components, max_iter=10, tol=1e-6,
+                 transform_n_nonzero_coefs=None):
+        """
+        Parameters
+        ----------
+        n_components:
+            Number of dictionary elements
+
+        max_iter:
+            Maximum number of iterations
+
+        tol:
+            tolerance for error
+
+        transform_n_nonzero_coefs:
+            Number of nonzero coefficients to target
+        """
+        self.components_ = None
+        self.max_iter = max_iter
+        self.tol = tol
+        self.n_components = n_components
+        self.transform_n_nonzero_coefs = transform_n_nonzero_coefs
+
+    def _update_dict(self, X, D, gamma):
+        for j in range(self.n_components):
+            I = gamma[:, j] > 0
+            if np.sum(I) == 0:
+                continue
+
+            D[j, :] = 0
+            g = gamma[I, j].T
+            r = X[I, :] - gamma[I, :].dot(D)
+            d = r.T.dot(g)
+            d /= np.linalg.norm(d)
+            g = r.dot(d)
+            D[j, :] = d
+            gamma[I, j] = g.T
+        return D, gamma
+
+    def _initialize(self, X):
+        if min(X.shape) < self.n_components:
+            D = np.random.randn(self.n_components, X.shape[1])
+        else:
+            u, s, vt = sp.sparse.linalg.svds(X, k=self.n_components)
+            D = np.dot(np.diag(s), vt)
+        D /= np.linalg.norm(D, axis=1)[:, np.newaxis]
+        return D
+
+    def _transform(self, D, X):
+        gram = D.dot(D.T)
+        Xy = D.dot(X.T)
+
+        n_nonzero_coefs = self.transform_n_nonzero_coefs
+        if n_nonzero_coefs is None:
+            n_nonzero_coefs = int(0.1 * X.shape[1])
+
+        return orthogonal_mp_gram(
+            gram, Xy, n_nonzero_coefs=n_nonzero_coefs).T
+
+    def fit(self, X):
+        """
+        Parameters
+        ----------
+        X: shape = [n_samples, n_features]
+        """
+        D = self._initialize(X)
+        for i in range(self.max_iter):
+            gamma = self._transform(D, X)
+            e = np.linalg.norm(X - gamma.dot(D))
+            if e < self.tol:
+                break
+            D, gamma = self._update_dict(X, D, gamma)
+
+        self.components_ = D
+        return self
+
+    def transform(self, X):
+        return self._transform(self.components_, X)

graph_dictlearn-0.1.0/src/graph_dictlearn/encoders/__init__.py

@@ -0,0 +1,5 @@
+"""Graph encoder implementations."""
+
+from graph_dictlearn.encoders.wl import WL
+
+__all__ = ["WL"]

graph_dictlearn-0.1.0/src/graph_dictlearn/encoders/base.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+import random
+import numpy as np
+import networkx as nx
+from typing import List
+
+# abstract base class
+class GraphEncoder(ABC):
+    def __init__(self, name: str):
+        super().__init__()
+        self.name = name
+        self.embeddings = None
+
+    @abstractmethod
+    def generate_training_embeddings(self, graphs):
+        pass
+
+    @abstractmethod
+    def generate_inferencing_embeddings(self, graphs):
+        pass
+
+    def _set_seed(self):
+        """Creating the initial random seed."""
+        random.seed(self.seed)
+        np.random.seed(self.seed)
+
+    @staticmethod
+    def _ensure_integrity(graph: nx.classes.graph.Graph) -> nx.classes.graph.Graph:
+        """Ensure walk traversal conditions."""
+        edge_list = [(index, index) for index in range(graph.number_of_nodes())]
+        graph.add_edges_from(edge_list)
+
+        return graph
+
+    @staticmethod
+    def _check_indexing(graph: nx.classes.graph.Graph):
+        """Checking the consecutive numeric indexing."""
+        numeric_indices = [index for index in range(graph.number_of_nodes())]
+        node_indices = sorted([node for node in graph.nodes()])
+
+        assert numeric_indices == node_indices, "The node indexing is wrong."
+
+    def _check_graph(self, graph: nx.classes.graph.Graph) -> nx.classes.graph.Graph:
+        """Check the Karate Club assumptions about the graph."""
+        self._check_indexing(graph)
+        graph = self._ensure_integrity(graph)
+
+        return graph
+
+    def _check_graphs(self, graphs: List[nx.classes.graph.Graph]):
+        """Check the Karate Club assumptions for a list of graphs."""
+        graphs = [self._check_graph(graph) for graph in graphs]
+
+        return graphs

graph_dictlearn-0.1.0/src/graph_dictlearn/encoders/wl.py

@@ -0,0 +1,147 @@
+import numpy as np
+from gensim.models.doc2vec import TaggedDocument
+from graph_dictlearn.encoders.base import GraphEncoder
+from graph_dictlearn.encoders.wl_hashing import WeisfeilerLehmanHashing
+from collections import Counter
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+class WL(GraphEncoder):
+    def __init__(
+            self,
+            wl_iterations: int = 2,
+            attributed: bool = True,
+            erase_base_features: bool = True,
+            n_vocab: int = 1000,
+            min_features: int = 50,
+            seed: int = 42
+    ):
+
+        super().__init__(name="ImbalanceAwareWL")
+
+        self.seed = seed
+        self.vocab = None
+        self.graph_embeddings = None
+        self.wl_iterations = wl_iterations
+        self.attributed = attributed
+        self.erase_base_features = erase_base_features
+        self.n_vocab = n_vocab
+        self.min_features = min_features
+
+    def create_wl_hash(self, graph_list):
+
+        documents = []
+
+        for graph in graph_list:
+            g = self._check_graph(graph)
+
+            document = WeisfeilerLehmanHashing(
+                g, self.wl_iterations, self.attributed, self.erase_base_features)
+
+            documents.append(document)
+
+        documents = [
+            TaggedDocument(words=doc.get_graph_features(), tags=[str(i)])
+            for i, doc in enumerate(documents)
+        ]
+
+        return documents
+
+    def create_vocab(self, corpus, labels):
+        majority_df = Counter()
+        minority_df = Counter()
+
+        majority_graphs = 0
+        minority_graphs = 0
+
+        for doc, label in zip(corpus, labels):
+
+            # unique subtree hashes in this graph
+            # document frequency instead of raw counts
+            unique_words = Counter(doc.words)
+            if label == -1:
+                majority_graphs += 1
+                for word in unique_words:
+                    majority_df[word] += 1
+            else:
+                minority_graphs += 1
+                for word in unique_words:
+                    minority_df[word] += 1
+
+        all_words = set(list(majority_df.keys()) + list(minority_df.keys()))
+
+        scored_vocab = []
+
+        for word in all_words:
+            p_majority = majority_df[word] / majority_graphs
+
+            p_minority = (minority_df[word] / minority_graphs)
+
+            discriminative_score = abs(np.sqrt(p_majority) - np.sqrt(p_minority))
+
+            total_presence = p_majority + p_minority
+
+            # Final score
+
+            score = total_presence * discriminative_score
+            scored_vocab.append((word, score))
+
+        # Sort features by discriminative importance
+        scored_vocab = sorted(
+            scored_vocab,
+            key=lambda x: x[1],
+            reverse=True
+        )
+
+        # selection
+        scores = np.array([x[1] for x in scored_vocab])
+
+        threshold = scores.mean() - scores.std()
+        trimmed_vocab = [item for item in scored_vocab if item[1] >= threshold]
+
+        # fallback if too few selected
+        logger.info("Selected %d features from adaptive selection", len(trimmed_vocab))
+        if len(trimmed_vocab) < 50:
+            trimmed_vocab = scored_vocab[:self.n_vocab]
+
+        self.n_vocab = len(trimmed_vocab)
+        return trimmed_vocab
+
+    def calc_coefficients(self, corpus):
+
+        sparse_vector = np.zeros([len(corpus), self.n_vocab])
+
+        i = 0
+        for corpus in corpus:
+            words = corpus.words
+
+            words_count = Counter(corpus.words)
+            j = 0
+            for atom, _ in self.vocab:
+                sparse_vector[i][j] = words_count[atom]
+                j = j + 1
+
+            i = i + 1
+
+        norms = np.linalg.norm(sparse_vector, axis=1, keepdims=True)
+        norms[norms == 0] = 1.0
+        sparse_vector = sparse_vector / norms
+
+        return sparse_vector
+
+    def generate_training_embeddings(self, graphs, labels):
+        self._set_seed()
+        documents = self.create_wl_hash(graphs)
+        self.vocab = self.create_vocab(documents, labels)
+        train_graph_embeddings = self.calc_coefficients(documents)
+        return train_graph_embeddings
+
+    def generate_inferencing_embeddings(self, graphs):
+        self._set_seed()
+        documents = self.create_wl_hash(graphs)
+        infer_graph_embeddings = self.calc_coefficients(
+            documents
+        )
+        return infer_graph_embeddings

graph_dictlearn-0.1.0/src/graph_dictlearn/encoders/wl_hashing.py

@@ -0,0 +1,97 @@
+import hashlib
+import networkx as nx
+from typing import List, Dict
+
+
+class WeisfeilerLehmanHashing(object):
+    """
+    Weisfeiler-Lehman feature extractor class.
+
+    Args:
+        graph (NetworkX graph): NetworkX graph for which we do WL hashing.
+        wl_iterations (int): Number of WL iterations.
+        attributed (bool): Presence of attributes.
+        erase_base_feature (bool): Deleting the base features.
+    """
+
+    def __init__(
+        self,
+        graph: nx.classes.graph.Graph,
+        wl_iterations: int,
+        attributed: bool,
+        erase_base_features: bool,
+    ):
+        """
+        Initialization method which also executes feature extraction.
+        """
+        self.wl_iterations = wl_iterations
+        self.graph = graph
+        self.attributed = attributed
+        self.erase_base_features = erase_base_features
+        self._set_features()
+        self._do_recursions()
+
+    def _set_features(self):
+        """
+        Creating the features.
+        """
+        if self.attributed:
+            self.features = nx.get_node_attributes(self.graph, "feature")
+        else:
+            self.features = {
+                node: self.graph.degree(node) for node in self.graph.nodes()
+            }
+        self.extracted_features = {k: [str(v)] for k, v in self.features.items()}
+
+    def _erase_base_features(self):
+        """
+        Erasing the base features
+        """
+        for k, v in self.extracted_features.items():
+            del self.extracted_features[k][0]
+
+    def _do_a_recursion(self):
+        """
+        The method does a single WL recursion.
+
+        Return types:
+            * **new_features** *(dict of strings)* - The hash table with extracted WL features.
+        """
+        new_features = {}
+        for node in self.graph.nodes():
+            nebs = self.graph.neighbors(node)
+            degs = [self.features[neb] for neb in nebs]
+            features = [str(self.features[node])] + sorted([str(deg) for deg in degs])
+            features = "_".join(features)
+            hash_object = hashlib.md5(features.encode())
+            hashing = hash_object.hexdigest()
+            new_features[node] = hashing
+        self.extracted_features = {
+            k: self.extracted_features[k] + [v] for k, v in new_features.items()
+        }
+        return new_features
+
+    def _do_recursions(self):
+        """
+        The method does a series of WL recursions.
+        """
+        for _ in range(self.wl_iterations):
+            self.features = self._do_a_recursion()
+        if self.erase_base_features:
+            self._erase_base_features()
+
+    def get_node_features(self) -> Dict[int, List[str]]:
+        """
+        Return the node level features.
+        """
+        return self.extracted_features
+
+    def get_graph_features(self) -> List[str]:
+        """
+        Return the graph level features.
+        """
+        return [
+            feature
+            for node, features in self.extracted_features.items()
+            for feature in features
+        ]

graph_dictlearn-0.1.0/src/graph_dictlearn/loader/__init__.py

@@ -0,0 +1,5 @@
+"""Graph data loaders."""
+
+from graph_dictlearn.loader.loader import SDFLoader
+
+__all__ = ["SDFLoader"]

graph_dictlearn-0.1.0/src/graph_dictlearn/loader/loader.py

@@ -0,0 +1,86 @@
+"""Generic graph data loader for SDF molecular files."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import List, Tuple
+
+import networkx as nx
+from rdkit import Chem
+
+logger = logging.getLogger(__name__)
+
+
+class SDFLoader:
+    """Load molecular graphs and labels from an SDF file.
+
+    Parameters
+    ----------
+    filepath : str or Path
+        Path to the .sdf file.
+    label_property : str
+        SDF molecule property that holds the class label. Defaults to "value".
+    remove_hydrogens : bool
+        Whether to strip explicit hydrogens. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        filepath: str | Path,
+        label_property: str = "value",
+        remove_hydrogens: bool = False,
+    ) -> None:
+        self.filepath = Path(filepath)
+        self.label_property = label_property
+        self.remove_hydrogens = remove_hydrogens
+
+        if not self.filepath.exists():
+            raise FileNotFoundError(f"SDF file not found: {self.filepath}")
+        if self.filepath.suffix.lower() != ".sdf":
+            raise ValueError(f"Expected an .sdf file, got '{self.filepath.suffix}'")
+
+    def load(self) -> Tuple[List[nx.Graph], List[int]]:
+        """Read the SDF file and return (graphs, labels)."""
+        supplier = Chem.SDMolSupplier(
+            str(self.filepath),
+            removeHs=self.remove_hydrogens,
+        )
+
+        graphs: List[nx.Graph] = []
+        labels: List[int] = []
+
+        for mol in supplier:
+            if mol is None:
+                continue
+
+            graph = self._mol_to_graph(mol)
+            label = int(float(mol.GetProp(self.label_property)))
+
+            graphs.append(graph)
+            labels.append(label)
+
+        logger.info("Loaded %d graphs from %s", len(graphs), self.filepath.name)
+        return graphs, labels
+
+    @staticmethod
+    def _mol_to_graph(mol) -> nx.Graph:
+        """Convert an RDKit Mol to a NetworkX graph."""
+        graph = nx.Graph()
+
+        for atom in mol.GetAtoms():
+            graph.add_node(atom.GetIdx(), feature=atom.GetSymbol())
+
+        for bond in mol.GetBonds():
+            graph.add_edge(
+                bond.GetBeginAtomIdx(),
+                bond.GetEndAtomIdx(),
+                bond_type=str(bond.GetBondType()),
+                bond_order=bond.GetBondTypeAsDouble(),
+                aromatic=bond.GetIsAromatic(),
+                in_ring=bond.IsInRing(),
+                conjugated=bond.GetIsConjugated(),
+                stereo=str(bond.GetStereo()),
+            )
+
+        return graph

graph_dictlearn-0.1.0/src/graph_dictlearn.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: graph_dictlearn
+Version: 0.1.0
+Summary: A set of representation learning and dictionary learning algorithms for graph data.
+Author-email: Nimendra Gnawardana <nimendraamiththa1@gmail.com>, Siyathma Wedamulla <wedamullasiyathma@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nimendra-ag/graph_dictlearn
+Project-URL: Repository, https://github.com/nimendra-ag/graph_dictlearn
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gensim==4.4.0
+Requires-Dist: joblib==1.5.3
+Requires-Dist: matplotlib==3.11.0
+Requires-Dist: networkx==3.6.1
+Requires-Dist: numpy==2.5.0
+Requires-Dist: pandas==3.0.3
+Requires-Dist: rdkit==2026.3.3
+Requires-Dist: scikit-learn==1.9.0
+Requires-Dist: scipy==1.18.0
+Requires-Dist: seaborn==0.13.2
+Dynamic: license-file
+
+# graph_dictlearn
+A set of representation learning and dictionary learning algorithms for graph data.
+
+You can use this pip package to apply dictionary learning algorithms for graph data.

graph_dictlearn-0.1.0/src/graph_dictlearn.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/graph_dictlearn/__init__.py
+src/graph_dictlearn.egg-info/PKG-INFO
+src/graph_dictlearn.egg-info/SOURCES.txt
+src/graph_dictlearn.egg-info/dependency_links.txt
+src/graph_dictlearn.egg-info/requires.txt
+src/graph_dictlearn.egg-info/top_level.txt
+src/graph_dictlearn/dict_learners/__init__.py
+src/graph_dictlearn/dict_learners/aksvd.py
+src/graph_dictlearn/dict_learners/base.py
+src/graph_dictlearn/dict_learners/ksvd.py
+src/graph_dictlearn/encoders/__init__.py
+src/graph_dictlearn/encoders/base.py
+src/graph_dictlearn/encoders/wl.py
+src/graph_dictlearn/encoders/wl_hashing.py
+src/graph_dictlearn/loader/__init__.py
+src/graph_dictlearn/loader/loader.py

graph_dictlearn-0.1.0/src/graph_dictlearn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

graph_dictlearn-0.1.0/src/graph_dictlearn.egg-info/requires.txt

@@ -0,0 +1,10 @@
+gensim==4.4.0
+joblib==1.5.3
+matplotlib==3.11.0
+networkx==3.6.1
+numpy==2.5.0
+pandas==3.0.3
+rdkit==2026.3.3
+scikit-learn==1.9.0
+scipy==1.18.0
+seaborn==0.13.2

graph_dictlearn-0.1.0/src/graph_dictlearn.egg-info/top_level.txt

@@ -0,0 +1 @@
+graph_dictlearn