ddi-fw 0.0.50__py3-none-any.whl → 0.0.52__py3-none-any.whl

ddi_fw/datasets/ddi_mdl/base.py

@@ -7,16 +7,48 @@ from .. import BaseDataset
 from ..db_utils import create_connection
 
 HERE = pathlib.Path(__file__).resolve().parent
+list_of_embedding_columns = ['all_text', 'description',
+                     'synthesis_reference', 'indication',
+                     'pharmacodynamics', 'mechanism_of_action',
+                     'toxicity', 'metabolism',
+                     'absorption', 'half_life',
+                     'protein_binding', 'route_of_elimination',
+                     'volume_of_distribution', 'clearance']
+
+list_of_chemical_property_columns = ['enzyme',
+                             'target',
+                             'pathway',
+                             'smile']
+list_of_ner_columns = ['tui', 'cui', 'entities']
 
 
 class DDIMDLDataset(BaseDataset):
-    def __init__(self, embedding_size, embedding_dict, embeddings_pooling_strategy: PoolingStrategy, ner_df, chemical_property_columns=['enzyme',
-                                                                                                                                        'target',
-                                                                                                                                        'pathway',
-                                                                                                                                        'smile'],
+    def __init__(self, embedding_size,
+                 embedding_dict,
+                 embeddings_pooling_strategy: PoolingStrategy,
+                 ner_df,
+                 chemical_property_columns=['enzyme',
+                                            'target',
+                                            'pathway',
+                                            'smile'],
                  embedding_columns=[],
                  ner_columns=[],
                  **kwargs):
+        columns = kwargs['columns']
+        if columns is not None:
+            chemical_property_columns = []
+            embedding_columns=[]
+            ner_columns=[]
+            for column in columns:
+                if column in list_of_chemical_property_columns:
+                    chemical_property_columns.append(column)
+                elif column in list_of_embedding_columns:
+                    embedding_columns.append(column)
+                elif column in list_of_ner_columns:
+                    ner_columns.append(column)
+                else:
+                    raise Exception(f"{column} is not related this dataset")
+
 
         super().__init__(embedding_size=embedding_size,
                          embedding_dict=embedding_dict,

ddi_fw/experiments/__init__.py

@@ -1,2 +1,3 @@
-from .tensorflow_helper import TFMultiModal, TFSingleModal
-from .evaluation_helper import evaluate, Metrics
+from .tensorflow_helper import TFMultiModal, TFSingleModal,Result
+from .evaluation_helper import evaluate, Metrics
+from .pipeline import Experiment

ddi_fw/experiments/pipeline.py

@@ -0,0 +1,126 @@
+import sqlite3
+from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
+from keras.models import Model, Sequential
+from keras.callbacks import EarlyStopping
+from keras.layers import Dense, Dropout, Input, Activation, BatchNormalization
+from tensorflow import keras
+from ddi_fw.experiments import TFSingleModal, TFMultiModal
+from ddi_fw.experiments import evaluate
+from sklearn.preprocessing import LabelBinarizer
+import numpy as np
+import pandas as pd
+from ddi_fw.utils import ZipHelper, Py7ZipHelper
+import os
+import chromadb
+from collections import defaultdict
+from langchain_community.vectorstores import Chroma
+from ddi_fw.ner.ner import CTakesNER
+from ddi_fw.datasets.embedding_generator_new import PoolingStrategy
+
+from ddi_fw.datasets import BaseDataset, DDIMDLDataset
+
+from ddi_fw.datasets import SumPoolingStrategy
+from keras import metrics
+from ddi_fw.experiments.evaluation_helper import evaluate
+
+import mlflow
+
+
+class Experiment:
+    def __init__(self, 
+                 experiment_name=None, 
+                 experiment_description=None, 
+                 experiment_tags=None, 
+                 tracking_uri=None, 
+                 dataset_type:BaseDataset=None, 
+                 columns=None, 
+                 vector_db_persist_directory=None, 
+                 vector_db_collection_name=None, 
+                 embedding_pooling_strategy_type:PoolingStrategy=None, 
+                 ner_data_file=None, 
+                 ner_threshold=None, 
+                 combinations=None, 
+                 model=None):
+        
+        self.experiment_name = experiment_name
+        self.experiment_description = experiment_description
+        self.experiment_tags = experiment_tags
+        self.tracking_uri = tracking_uri
+        self.dataset_type = dataset_type
+        self.columns = columns
+        self.vector_db_persist_directory = vector_db_persist_directory
+        self.vector_db_collection_name = vector_db_collection_name
+        self.embedding_pooling_strategy_type = embedding_pooling_strategy_type
+        self.ner_data_file = ner_data_file
+        self.ner_threshold = ner_threshold
+        self.combinations = combinations
+        self.model = model
+
+    def build(self):
+        # 'enzyme','target','pathway','smile','all_text','indication', 'description','mechanism_of_action','pharmacodynamics', 'tui', 'cui', 'entities'
+        kwargs = {"columns": self.columns}
+        for k, v in self.ner_threshold.items():
+            kwargs[k] = v
+
+        self.vector_db = chromadb.PersistentClient(
+            path=self.vector_db_persist_directory)
+        self.collection = self.vector_db.get_collection(
+            self.vector_db_collection_name)
+        dictionary = self.collection.get(include=['embeddings', 'metadatas'])
+
+        embedding_dict = defaultdict(lambda: defaultdict(list))
+
+        for metadata, embedding in zip(dictionary['metadatas'], dictionary['embeddings']):
+            embedding_dict[metadata["type"]][metadata["id"]].append(embedding)
+
+        embedding_size = dictionary['embeddings'].shape[1]
+
+        pooling_strategy = self.embedding_pooling_strategy_type()
+
+        self.ner_df = CTakesNER().load(filename=self.ner_data_file)  if self.ner_data_file else None
+
+        self.dataset = self.dataset_type(
+            embedding_dict=embedding_dict,
+            embedding_size=embedding_size,
+            embeddings_pooling_strategy=pooling_strategy,
+            ner_df=self.ner_df, kwargs=kwargs)
+
+        X_train, X_test, y_train, y_test, X_train.index, X_test.index, train_idx_arr, val_idx_arr = self.dataset.load()
+
+        self.dataframe = self.dataset.dataframe
+        # dataframe.dropna()
+        self.X_train = self.dataset.X_train
+        self.X_test = self.dataset.X_test
+        self.y_train = self.dataset.y_train
+        self.y_test = self.dataset.y_test
+        self.train_idx_arr = self.dataset.train_idx_arr
+        self.val_idx_arr = self.dataset.val_idx_arr
+        # Logic to set up the experiment
+        self.items = self.dataset.produce_inputs()
+
+        unique_classes = pd.unique(self.dataframe['event_category'])
+        event_num = len(unique_classes)
+        # droprate = 0.3
+        vector_size = self.dataset.drugs_df.shape[0]
+
+        print("Building the experiment with the following settings:")
+        print(
+            f"Name: {self.experiment_name}, Dataset: {self.dataset}, Model: {self.model}")
+        # Implement additional build logic as needed
+        return self
+
+    def run(self, model_func, batch_size=128, epochs=100):
+        mlflow.set_tracking_uri(self.tracking_uri)
+
+        if mlflow.get_experiment_by_name(self.experiment_name) == None:
+            mlflow.create_experiment(self.experiment_name)
+            mlflow.set_experiment_tags(self.experiment_tags)
+        mlflow.set_experiment(self.experiment_name)
+
+        y_test_label = self.items[0][4]
+        multi_modal = TFMultiModal(
+            model_func=model_func, batch_size=batch_size,  epochs=epochs)  # 100
+        multi_modal.set_data(
+            self.items, self.train_idx_arr, self.val_idx_arr, y_test_label)
+        result = multi_modal.predict(self.combinations)
+        return result

ddi_fw/experiments/pipeline_builder_pattern.py

@@ -0,0 +1,152 @@
+import sqlite3
+from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
+from keras.models import Model, Sequential
+from keras.callbacks import EarlyStopping
+from keras.layers import Dense, Dropout, Input, Activation, BatchNormalization
+from tensorflow import keras
+from ddi_fw.experiments import TFSingleModal, TFMultiModal
+from ddi_fw.experiments import evaluate
+from sklearn.preprocessing import LabelBinarizer
+import numpy as np
+import pandas as pd
+from ddi_fw.utils import ZipHelper, Py7ZipHelper
+import os
+import chromadb
+from collections import defaultdict
+from langchain_community.vectorstores import Chroma
+from ddi_fw.ner.ner import CTakesNER
+from ddi_fw.datasets.embedding_generator_new import PoolingStrategy
+
+from ddi_fw.datasets import BaseDataset, DDIMDLDataset
+
+from ddi_fw.datasets import SumPoolingStrategy
+from keras import metrics
+from ddi_fw.experiments.evaluation_helper import evaluate
+
+import mlflow
+
+
+class Experiment:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def create():
+        return Experiment()
+
+    def name(self, name):
+        self.experiment_name = name
+        return self
+
+    def description(self, description):
+        self.experiment_description = description
+        return self
+
+    def tags(self, tags):
+        self.experiment_tags = tags
+        return self
+
+    def tracking_uri(self, uri):
+        self.tracking_uri = uri
+        return self
+
+    def dataset(self, dataset_type: BaseDataset):
+        self.dataset_type = dataset_type
+        return self
+
+    def columns(self, cols):
+        self.columns = cols
+        return self
+
+    def vectordb_collection(self, persist_directory, collection_name):
+        self.vector_db_persist_directory = persist_directory
+        self.vector_db_collection_name = collection_name
+        return self
+
+    def embedding_pooling_strategy(self, strategy_type: PoolingStrategy):
+        self.embedding_pooling_strategy_type = strategy_type
+        return self
+
+    def ner_data_file(self, ner_data_file):
+        self.ner_data_file = ner_data_file
+        self.ner_df = CTakesNER().load(filename=ner_data_file)
+        return self
+
+    def ner_threshold(self, threshold):
+        self.ner_threshold = threshold
+        return self
+
+    def combinations(self, combs):
+        self.combinations = combs
+        return self
+
+    def model(self, model):
+        self.model = model
+        return self
+
+    def build(self):
+        # 'enzyme','target','pathway','smile','all_text','indication', 'description','mechanism_of_action','pharmacodynamics', 'tui', 'cui', 'entities'
+        kwargs = {"columns": self.columns}
+        for k, v in self.ner_threshold.items():
+            kwargs[k] = v
+
+        self.vector_db = chromadb.PersistentClient(
+            path=self.vector_db_persist_directory)
+        self.collection = self.vector_db.get_collection(
+            self.vector_db_collection_name)
+        dictionary = self.collection.get(include=['embeddings', 'metadatas'])
+
+        embedding_dict = defaultdict(lambda: defaultdict(list))
+
+        for metadata, embedding in zip(dictionary['metadatas'], dictionary['embeddings']):
+            embedding_dict[metadata["type"]][metadata["id"]].append(embedding)
+
+        embedding_size = dictionary['embeddings'].shape[1]
+
+        pooling_strategy = self.embedding_pooling_strategy_type()
+
+        self.dataset = self.dataset_type(
+            embedding_dict=embedding_dict,
+            embedding_size=embedding_size,
+            embeddings_pooling_strategy=pooling_strategy,
+            ner_df=self.ner_df, kwargs=kwargs)
+
+        X_train, X_test, y_train, y_test, X_train.index, X_test.index, train_idx_arr, val_idx_arr = self.dataset.load()
+
+        self.dataframe = self.dataset.dataframe
+        # dataframe.dropna()
+        self.X_train = self.dataset.X_train
+        self.X_test = self.dataset.X_test
+        self.y_train = self.dataset.y_train
+        self.y_test = self.dataset.y_test
+        self.train_idx_arr = self.dataset.train_idx_arr
+        self.val_idx_arr = self.dataset.val_idx_arr
+        # Logic to set up the experiment
+        self.items = self.dataset.produce_inputs()
+
+        unique_classes = pd.unique(self.dataframe['event_category'])
+        event_num = len(unique_classes)
+        # droprate = 0.3
+        vector_size = self.dataset.drugs_df.shape[0]
+
+        print("Building the experiment with the following settings:")
+        print(
+            f"Name: {self.experiment_name}, Dataset: {self.dataset}, Model: {self.model}")
+        # Implement additional build logic as needed
+        return self
+
+    def run(self, model_func, batch_size=128, epochs=100):
+        mlflow.set_tracking_uri(self.tracking_uri)
+
+        if mlflow.get_experiment_by_name(self.experiment_name) == None:
+            mlflow.create_experiment(self.experiment_name)
+            mlflow.set_experiment_tags(self.experiment_tags)
+        mlflow.set_experiment(self.experiment_name)
+
+        y_test_label = self.items[0][4]
+        multi_modal = TFMultiModal(
+            model_func=model_func, batch_size=batch_size,  epochs=epochs)  # 100
+        multi_modal.set_data(
+            self.items, self.train_idx_arr, self.val_idx_arr, y_test_label)
+        pred, self.single_results = multi_modal.predict(self.combinations)
+        return self

ddi_fw/experiments/tensorflow_helper.py

@@ -30,12 +30,25 @@ np.random.seed(2)
 np.set_printoptions(precision=4)
 
 
+class Result:
+    def __init__(self) -> None:
+        self.log_dict = {}
+        self.metric_dict = {}
+
+    def add_log(self, key, logs):
+        self.log_dict[key] = logs
+
+    def add_metric(self, key, metrics):
+        self.metric_dict[key] = metrics
+
+
 class TFMultiModal:
     # todo model related parameters to config
     def __init__(self, model_func, batch_size=128, epochs=100):
         self.model_func = model_func
         self.batch_size = batch_size
         self.epochs = epochs
+        self.result = Result()
 
     def set_data(self, items, train_idx_arr, val_idx_arr, y_test_label):
         self.items = items
@@ -64,14 +77,16 @@ class TFMultiModal:
                     self.date, item[0], self.model_func, self.batch_size, self.epochs)
                 single_modal.set_data(
                     self.train_idx_arr, self.val_idx_arr, item[1], item[2], item[3], item[4])
-                r = single_modal.predict()
-                single_results[item[0]] = r
-                sum = sum + r
+                logs, metrics, prediction = single_modal.predict()
+                self.result.add_log(item[0], logs)
+                self.result.add_metric(item[0], metrics)
+                single_results[item[0]] = prediction
+                # sum = sum + prediction
 
             if combinations:
                 self.evaluate_combinations(single_results, combinations)
         # TODO: sum'a gerek yok
-        return sum, single_results
+        return self.result
 
     def evaluate_combinations(self, single_results, combinations):
         for combination in combinations:
@@ -90,6 +105,8 @@ class TFMultiModal:
                     f'combination_artifact_uri:{combination_run.info.artifact_uri}')
                 utils.compress_and_save_data(
                     metrics.__dict__, combination_run.info.artifact_uri, f'{self.date}_metrics.gzip')
+                self.result.add_log(combination_descriptor,logs)
+                self.result.add_metric(combination_descriptor,metrics)
 
 
 class TFSingleModal:
@@ -172,39 +189,8 @@ class TFSingleModal:
             #           '/model/model.onnx')
             utils.compress_and_save_data(
                 metrics.__dict__, run.info.artifact_uri, f'{self.date}_metrics.gzip')
-            # mlflow.log_dict(metrics.__dict__, "metrics.json")
-
-            # Plot Precision-Recall curves for each class and micro-average
-            # fig = plt.figure()
-            # plt.step(metrics.recall['micro_event'], metrics.precision['micro_event'],
-            #          color='b', alpha=0.2, where='post')
-            # plt.fill_between(
-            #     metrics.recall["micro_event"], metrics.precision["micro_event"], step='post', alpha=0.2, color='b')
-
-            # for i in range(pred.shape[1]):
-            #     plt.step(metrics.recall[i], metrics.precision[i], where='post',
-            #              label='Class {0} (AUC={1:0.2f})'.format(i, metrics.roc_aupr[i]))
-
-            # plt.xlabel('Recall')
-            # plt.ylabel('Precision')
-            # plt.ylim([0.0, 1.05])
-            # plt.xlim([0.0, 1.0])
-            # plt.title(
-            #     'Micro-average Precision-Recall curve: AUC={0:0.2f}'.format(metrics.roc_aupr["micro"]))
-            # plt.legend(loc='best')
-            # # plt.savefig(run.info.artifact_uri + '/auprc.png')
-            # mlflow.log_figure(fig, 'auprc.png')
-
-            # mlflow.log_model(
-            #         model,
-            #         artifact_path=run.info.artifact_uri + '/model',
-            #         signature=signature,
-            #     )
-            # mlflow.log_artifact(run.info.artifact_uri + '/model')
-
-            # mlflow.MlflowClient().log_artifact(run.info.run_id,
-            #                                    run.info.artifact_uri, None)
-        return pred
+
+        return logs, metrics, pred
 
 
 class CustomCallback(keras.callbacks.Callback):

ddi_fw/utils/py7zr_helper.py

@@ -5,7 +5,9 @@ import py7zr
 import os
 from os.path import basename
 
-
+# https://py7zr.readthedocs.io/en/latest/user_guide.html
+# import multivolumefile
+#https://github.com/miurahr/py7zr/issues/497
 class Py7ZipHelper:
     def __init__(self):
         pass
@@ -24,7 +26,7 @@ class Py7ZipHelper:
                                                   os.path.join(folder_path, '..')))
                     # archive.write(root+"/"+file)
 
-    def create_archive_multiparts(self, zip_name, file_path, output_path, chunk_size, delete_existing_files:True):
+    def create_archive_multiparts(self, zip_name, file_path, output_path, chunk_size, delete_existing_files=True):
         parent_folder = os.path.dirname(file_path)
         if delete_existing_files:
             clear_directory(output_path)

{ddi_fw-0.0.50.dist-info → ddi_fw-0.0.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddi_fw
-Version: 0.0.50
+Version: 0.0.52
 Summary: Do not use :)
 Author-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>
 Maintainer-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>

{ddi_fw-0.0.50.dist-info → ddi_fw-0.0.52.dist-info}/RECORD

@@ -6,7 +6,7 @@ ddi_fw/datasets/embedding_generator_new.py,sha256=GOE-Io6-DBwiUJSkgmxw9ZM1exCYYV
 ddi_fw/datasets/feature_vector_generation.py,sha256=dxTHvp6uTkao9PdThs116Q3bWw_WTo9T8WigVL4G01s,3245
 ddi_fw/datasets/idf_helper.py,sha256=_Gd1dtDSLaw8o-o0JugzSKMt9FpeXewTh4wGEaUd4VQ,2571
 ddi_fw/datasets/setup_._py,sha256=khYVJuW5PlOY_i_A16F3UbSZ6s6o_ljw33Byw3C-A8E,1047
-ddi_fw/datasets/ddi_mdl/base.py,sha256=eeMMwiyNYRD0-QyffWbPGvU0GeBR121KaDXusm5OtwI,3185
+ddi_fw/datasets/ddi_mdl/base.py,sha256=7MMAMJtJqqTXmYiI4Hf7e4kO2xoOynPocHazJrE9Y_w,4261
 ddi_fw/datasets/ddi_mdl/readme.md,sha256=WC6lpmsEKvIISnZqENY7TWtzCQr98HPpE3oRsBl8pIw,625
 ddi_fw/datasets/ddi_mdl/data/event.db,sha256=cmlSsf9MYjRzqR-mw3cUDnTnfT6FkpOG2yCl2mMwwew,30580736
 ddi_fw/datasets/ddi_mdl/indexes/test_indexes.txt,sha256=XVlDqYATckrQwNSXqMSKVBqyoN_Hg8SK6CL-XMdLADY,102176
@@ -56,10 +56,12 @@ ddi_fw/drugbank/drugbank_parser.py,sha256=lxUuhB0s8ef_aPNDs0V8ClKF7-KIWugNIV9gVs
 ddi_fw/drugbank/drugbank_processor.py,sha256=vmkt68n9nFLevufgGyXhOSDtTo4G1XzwT9PVncGTXtk,18127
 ddi_fw/drugbank/drugbank_processor_org.py,sha256=eO5Yset50P91qkic79RUXPoEuxRxQKFkKW0l4G29Mas,13322
 ddi_fw/drugbank/event_extractor.py,sha256=6odoZohhK7OdLF-LF0l-5BFq0_NMG_5jrFJbHrBXsI8,4600
-ddi_fw/experiments/__init__.py,sha256=UJwd2i3QcuaI1YjC_2yGCiLuEMTT5Yo7rDFxw89chIw,108
+ddi_fw/experiments/__init__.py,sha256=5tOuHtrypRdmJgE5E78YcySbjCdNSGkbY1H5DY_I7gw,149
 ddi_fw/experiments/custom_torch_model.py,sha256=iQ_R_EApzD2JCcASN8cie6D21oh7VCxaOQ45_dkiGwc,2576
 ddi_fw/experiments/evaluation_helper.py,sha256=pY69cezV3WzrXw1bduIwRJfah1w3wXJ2YyTNim1J7ko,9349
-ddi_fw/experiments/tensorflow_helper.py,sha256=t5ZHi2VYfu9fCv3VKxyt-Y49bfXMBzeIrqHk1qRcg-E,12728
+ddi_fw/experiments/pipeline.py,sha256=V9xhcZo8mgNPqLvn-Fw9N4TSUl3uSlEJLfBxU6KPl50,5301
+ddi_fw/experiments/pipeline_builder_pattern.py,sha256=q1PNEQFoO5U3UidEoGB8rgLA7KXr4FsJTXEug5c5UJg,5466
+ddi_fw/experiments/tensorflow_helper.py,sha256=Y-gD9qyqFFPl6HAvM_tIa5Y6em2YmafPCL1KMrK6eb8,11768
 ddi_fw/experiments/test.py,sha256=z1TfBpK75zGKpp2ZU8f6APjZlgBFthaCBN61YB9ma4o,2049
 ddi_fw/ner/__init__.py,sha256=JwhGXrepomxPSsGsg2b_xPRC72AjvxOIn2CW5Mvscn0,26
 ddi_fw/ner/mmlrestclient.py,sha256=NZta7m2Qm6I_qtVguMZhqtAUjVBmmXn0-TMnsNp0jpg,6859
@@ -77,10 +79,10 @@ ddi_fw/test/torch_cuda_test.py,sha256=R-4VGVErl_Ufk54DoZbgL_YXWoCYFyanIVWd6P39IE
 ddi_fw/test/type_guarding_test.py,sha256=KxjyBxohDu7lwpejalCj-REjtJ-k1S1wQbOB6TGY0O8,766
 ddi_fw/utils/__init__.py,sha256=x1ypYJRKJlbF9x4psHYGXj-YbDD8T_c28gXZkr03cdE,273
 ddi_fw/utils/enums.py,sha256=19eJ3fX5eRK_xPvkYcukmug144jXPH4X9zQqtsFBj5A,671
-ddi_fw/utils/py7zr_helper.py,sha256=8U3fq9U6Y6vSx-InQ444SxFLHvOQNFFe8bXJgBrPC-Y,4570
+ddi_fw/utils/py7zr_helper.py,sha256=dgfHqXDBWys1hmd1JlHhYyZGxrzYWi6siYiUq3bnLuI,4698
 ddi_fw/utils/utils.py,sha256=szwnxMTDRrZoeNRyDuf3aCbtzriwtaRk4mHSH3asLdA,4301
 ddi_fw/utils/zip_helper.py,sha256=YRZA4tKZVBJwGQM0_WK6L-y5MoqkKoC-nXuuHK6CU9I,5567
-ddi_fw-0.0.50.dist-info/METADATA,sha256=C4QuZ2hRXteDRlwN_SlebxopvrcRCo362XsgkWqU1KA,1565
-ddi_fw-0.0.50.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-ddi_fw-0.0.50.dist-info/top_level.txt,sha256=PMwHICFZTZtcpzQNPV4UQnfNXYIeLR_Ste-Wfc1h810,7
-ddi_fw-0.0.50.dist-info/RECORD,,
+ddi_fw-0.0.52.dist-info/METADATA,sha256=FQr0HEjL3fYVVd2y2_MjRpuhUGawIZIcr-K74oTX9g8,1565
+ddi_fw-0.0.52.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ddi_fw-0.0.52.dist-info/top_level.txt,sha256=PMwHICFZTZtcpzQNPV4UQnfNXYIeLR_Ste-Wfc1h810,7
+ddi_fw-0.0.52.dist-info/RECORD,,