vislearnlabpy 0.0.1__py3-none-any.whl

vislearnlabpy/embeddings/embedding_utils.py

@@ -0,0 +1,17 @@
+import pandas as pd
+
+def rename_csv_column(file, cols, new_name):
+        for col in cols:
+            if col in file.columns:
+                file = file.rename(columns={col: new_name})
+                return file # Rename only the first match
+
+def process_csv(input_csv):
+    images_df = pd.read_csv(input_csv)
+    text_cols = ['class_name', 'word', 'text']
+    image_cols = ['input_path', 'image_path']
+    if 'text1' not in images_df.columns:
+        images_df = rename_csv_column(images_df, text_cols, 'text1')
+    if 'image1' not in images_df.columns:
+        images_df = rename_csv_column(images_df, image_cols, 'image1')
+    return images_df

vislearnlabpy/embeddings/generate_embeddings.py

@@ -0,0 +1,40 @@
+from vislearnlabpy.models.clip_model import CLIPGenerator
+import torch
+import os
+from vislearnlabpy.embeddings.stimuli_loader import StimuliLoader
+import pandas as pd
+
+torch.set_num_threads(32)
+
+class EmbeddingGenerator():
+    def __init__(self, device=None, model_type="clip"):
+        if device is None:
+            self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+        self.model_type = model_type
+    
+    def generate_image_embeddings(self, output_path=os.getcwd(), overwrite=False, 
+                                  normalize=True, output_type="csv", input_csv=None, 
+                                  input_dir=None, batch_size=1):
+        if input_csv is None:
+            if input_dir is None:
+                raise Exception("Either input CSV or input image path needs to be provided")
+            images_dataloader = StimuliLoader(
+                image_folder=input_dir,
+                batch_size=batch_size,
+                stimuli_type="images"
+            ).dataloader()
+        else:
+            images_dataloader = StimuliLoader(
+                image_folder=input_dir,
+                dataset_file=input_csv,
+                batch_size=batch_size,
+                stimuli_type="images",
+                id_column="image1"
+            ).dataloader()
+        CLIPGenerator(device=self.device, dataloader=images_dataloader).save_image_embeddings(save_path=output_path,
+                                                                                       output_type=output_type, 
+                                                                                       normalize_embeddings=normalize, 
+                                                                                       overwrite=overwrite,
+                                                                                       )

vislearnlabpy/embeddings/stimuli_loader.py

@@ -0,0 +1,79 @@
+import os
+import pandas as pd
+import re
+from PIL import Image
+from torch.utils.data import Dataset, DataLoader
+from vislearnlabpy.embeddings.embedding_utils import process_csv
+import random
+
+random.seed(2)
+
+class StimuliDataset(Dataset):
+  def __init__(self, manifest, images_folder=None, id_column=None):
+    self.manifest = manifest
+    self.images_folder = images_folder
+    self.num_text_cols = sum(1 for c in self.manifest.columns if re.compile("text[0-9]").match(c))
+    self.num_image_cols = len([c for c in self.manifest.columns if re.compile("image[0-9]").match(c)])
+    self.id_column = id_column
+
+  def __len__(self):
+     return len(self.manifest)
+
+  def __getitem__(self, idx):
+    row = self.manifest.iloc[idx]
+    texts = [str(row[f"text{i}"]) for i in range(1, self.num_text_cols + 1)]
+    images = []
+    image_paths = self._get_image_paths(row)
+    for image_path in image_paths:
+      if image_path is None or not os.path.exists(image_path):
+        images.append(None)
+      else:
+        with Image.open(image_path).convert('RGB') as img:
+          images.append(img.copy())  # Copy the image data to memory
+    return {"images": images, "text": texts, "id": [row[self.id_column] if self.id_column is not None else random.randint(0, 1000000)]}
+
+  def _get_image_paths(self, row):
+    # If this is a text only dataset
+    if self.images_folder is None and self.num_image_cols == 0:
+      return [None] * self.num_text_cols
+    # If images are not in the manifest
+    elif self.num_image_cols == 0:
+      return [os.path.join(self.images_folder, row[f"text{i}"] + ".jpg") for i in range(1, self.num_text_cols + 1)]
+    else:
+      # allowing for a secondary image path to be provided with different images in the same stimuli sets stored in different subpaths
+      return [
+    os.path.join(*(self.images_folder,) if self.images_folder is not None else (), *(row["image_path"],) if "image_path" in row else (), row[f"image{i}"])
+    for i in range(1, self.num_image_cols + 1)]
+
+class StimuliLoader():
+  def __init__(self, dataset_file=None, batch_size=1, image_folder=None, id_column=None, stimuli_type='lookit', pairwise=False):
+    self.id_column = id_column
+    if dataset_file is None:
+      if image_folder is not None:
+        image_files = [
+          f for f in os.listdir(image_folder)
+          if (
+          os.path.isfile(os.path.join(image_folder, f)) and
+          not f.startswith("._") and
+          f.lower().endswith((".png", ".jpg", ".jpeg"))
+          )
+        ]
+        self.manifest = pd.DataFrame({'image1': image_files})
+        # assuming that the image path is a unique identifier if a specific ID column is not provided
+        self.id_column = "image1" if id_column is None else id_column
+      else: 
+        raise ValueError("Either image folder or dataset file needs to be provided")
+    else:
+      self.manifest = process_csv(dataset_file)
+    self.stimuli_type = stimuli_type
+    self.image_folder = image_folder
+    self.batch_size = batch_size
+    self.pairwise = pairwise
+  
+  def collator(self, batch):
+    return {key: [item for ex in batch for item in ex[key]] for key in batch[0]}
+     
+  def dataloader(self):
+    dataset = StimuliDataset(self.manifest, self.image_folder, self.id_column)
+    return DataLoader(dataset, batch_size=self.batch_size, collate_fn=self.collator)
+# TODO: allow for calculating all possible pairwise similarities in a space to do RSA etc.

vislearnlabpy/models/clip_model.py

@@ -0,0 +1,12 @@
+import clip
+from vislearnlabpy.models.multimodal_model import MultimodalModel
+
+class CLIPGenerator(MultimodalModel):
+    def __init__(self, dataloader=None, device=None):
+        self.model, self.preprocess = clip.load("ViT-B/32")
+        super().__init__(self.model, self.preprocess, dataloader, device)
+        self.name = "clip"
+    
+    def preprocess_text(self, text):
+        return clip.tokenize(f"a photo of a {text}").to(self.device)
+    

vislearnlabpy/models/feature_generator.py

@@ -0,0 +1,105 @@
+from abc import ABC, abstractmethod
+import itertools
+import pandas as pd
+import os
+import torch
+import random
+
+from tqdm import tqdm
+from torch.nn.functional import cosine_similarity
+random.seed(4)
+
+class FeatureGenerator(ABC):
+    """Abstract base class for generating similarity scores between pairs of concepts."""
+    def __init__(self, model, preprocess, dataloader, device=None, name="feature_generator"):
+        # working with tversky CPU capacity
+        torch.set_num_threads(1)
+        if device is None:
+            self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+        #model = torch.nn.DataParallel(model)
+        self.model = model.to(self.device)
+        self.model.eval()
+        self.preprocess = preprocess
+        self.name = name
+        self.dataloader = dataloader
+
+    def similarity(self, embeddings1, embeddings2):
+        # Compute cosine similarity
+        similarity_score = cosine_similarity(embeddings1, embeddings2)
+        return similarity_score.item()
+
+    # Normalize each embedding to have a unit L2 norm
+    def normalize_embeddings(self, embeddings):
+        return [embedding / embedding.norm(dim=-1, keepdim=True) for embedding in embeddings]
+
+    def save_similarities(self, sim_df: pd.DataFrame, save_path=None):
+        """Save similarity scores to CSV."""
+        self.save_df(sim_df, f'similarities-{self.name}_data.csv', save_path)
+
+    @abstractmethod
+    def similarities(self, stimulus1, stimulus2, dataloader_row):
+        """Compute similarity scores between two stimuli"""
+        pass
+
+    def format_similarity_row(self, word1, word2, similarity_score):
+        return {'target': word1, 'distractor': word2, **similarity_score}
+
+    def lookit_similarities(self, save_path=None):
+        """Calculate cosine similarities between all word pairs in the Lookit dataset"""
+        full_similarity_df = pd.DataFrame()
+        with torch.no_grad():
+            for d in tqdm(self.dataloader, desc=f"Calculating {self.name} similarities"):
+                similarity_data = []
+                # need to fix placing based on the stimuli set
+                text_set = set()
+                for count, (text1, text2) in enumerate(itertools.permutations(d['text'], 2)):
+                    images = [d['images'][d['text'].index(text1)], d['images'][d['text'].index(text2)]]
+                    pair = tuple(([text1, text2]))
+                    if pair not in text_set:
+                        curr_similarities = self.similarities(text1, text2, images)[0]
+                        curr_similarities["stimuli_id"] = d['id'][0]
+                        curr_similarities["row_id"] = f"{curr_similarities["stimuli_id"]}_{count}"
+                        similarity_data.append(self.format_similarity_row(text1, text2, curr_similarities))
+                        text_set.add(pair)
+                if len(similarity_data) > 0:
+                    similarity_df = pd.DataFrame(similarity_data)
+                    # Fix concatenation to handle empty DataFrames properly
+                    if full_similarity_df.empty:
+                        full_similarity_df = similarity_df
+                    else:
+                        full_similarity_df = pd.concat([full_similarity_df, similarity_df], ignore_index=True)
+                    self.save_similarities(similarity_df, save_path)
+        return full_similarity_df
+
+    def image_word_alignment(self, images, words):
+        """Compute alignment between a set of images and a list of words"""
+        inputs = self.preprocess(images=images, text=words, return_tensors="pt", padding=True)
+        return self.image_word_alignment(**inputs)
+    
+    def save_df(self, df, filename, save_path=None, overwrite=False):
+        """
+        Save dataframe to CSV, appending to existing file if it exists.
+        Avoids duplicate row_ids and handles new directory creation.
+        """
+        filepath = os.path.join(save_path, filename)
+        # create directory if it does not exist
+        if not os.path.exists(save_path):
+            os.makedirs(save_path)
+        if not os.path.exists(filepath):
+            df.to_csv(filepath, index=False)
+            return
+        try:
+            existing_df = pd.read_csv(filepath)
+            row_ids = df['row_id'].values
+            if overwrite:
+                # Remove rows from existing data that would be overwritten by new data
+                existing_df = existing_df[~existing_df['row_id'].isin(row_ids)]
+                existing_df.to_csv(filepath, index=False)             
+            else:
+                df = df[~df['row_id'].isin(existing_df['row_id'].values)]   
+            df.to_csv(filepath, mode='a', header=False, index=False)      
+        except pd.errors.EmptyDataError:
+            # Handle case where existing file is empty
+            df.to_csv(filepath, index=False)

vislearnlabpy/models/multimodal_model.py

@@ -0,0 +1,190 @@
+import itertools
+from vislearnlabpy.models.feature_generator import FeatureGenerator
+import torch
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+import os
+from pathlib import Path
+
+class MultimodalModel(FeatureGenerator):
+    """Abstract base class for multimodal models like CLIP and CVCL that extends FeatureGenerator"""
+    
+    def __init__(self, model, preprocess, dataloader=None, device=None):
+        super().__init__(model, preprocess, dataloader, device)
+        print(self.dataloader)
+        self.image_word_alignment = lambda **x: self.model(**x).logits_per_image.softmax(dim=-1).detach().cpu().numpy()
+
+    # Load and preprocess images
+    def preprocess_image(self, image):
+        return self.preprocess(image).unsqueeze(0).to(self.device)
+
+    def preprocess_text(self, text):
+        return self.model.tokenize(text).to(self.device)
+
+    def encode_image(self, image):
+        return self.model.encode_image(image)
+
+    def encode_text(self, text):
+        return self.model.encode_text(text)
+
+    def image_embeddings(self, images, normalize_embeddings=True):
+        """Get image embeddings"""
+        images = [self.preprocess_image(image) for image in images]
+        with torch.no_grad():
+            embeddings = [self.encode_image(image) for image in images]
+        if normalize_embeddings:
+            return self.normalize_embeddings(embeddings)
+        else:
+            return embeddings
+
+    def text_embeddings(self, words, normalize_embeddings=True):
+        """Get text embeddings"""
+        all_text_features = [self.preprocess_text(word) for word in words]
+        with torch.no_grad():
+            embeddings = [self.encode_text(text_features) for text_features in all_text_features]
+        if normalize_embeddings:
+            return self.normalize_embeddings(embeddings)
+        else:
+            return embeddings
+
+    def multimodal_embeddings(self, image_embeddings, text_embeddings):
+        """Get multimodal embeddings: by default, averages image and text embeddings"""
+        return [(a + b) / 2 for a, b in zip(image_embeddings, text_embeddings)]
+    
+    def text_to_images_logits(self, image_embeddings, text_embeddings, logit_scale=100):
+        """Get logits of text to image embedding dot products"""
+        return logit_scale * image_embeddings @ text_embeddings.t()
+    
+    def text_to_images_similarity(self, image_embeddings, text_embedding, logit_scale=100):
+        # Convert image_embeddings list to tensor if needed
+        if isinstance(image_embeddings, list):
+            image_embeddings = torch.stack(image_embeddings)
+        logits = self.text_to_images_logits(image_embeddings, text_embedding, logit_scale).to(self.device)
+        softmaxes = torch.nn.functional.softmax(logits, dim=0)
+        return softmaxes[1][0].item()
+    
+    def multimodal_luce(self, image_embeddings, text_embedding):
+        target_similarity = self.similarity(image_embeddings[0], text_embedding)
+        distractor_similarity = self.similarity(image_embeddings[1], text_embedding)
+        luce = distractor_similarity / (distractor_similarity + target_similarity)
+        return luce
+
+    def similarities(self, word1, word2, images):
+        valid_images = [img for img in images if img is not None]
+        similarity_scores = []
+        # TODO: this only returns the similarity scores for the first pair of images: need to separate out, indexing is weird
+        for image1, image2 in itertools.combinations(valid_images, 2):
+            curr_image_embeddings = self.image_embeddings([image1, image2])
+            curr_text_embeddings = self.text_embeddings([word1, word2])
+            # TODO: need to fix how each row is labeled in lookit_similarities, 
+            similarity_scores.append({
+                'image_similarity': self.similarity(curr_image_embeddings[0], curr_image_embeddings[1]),
+                'text_similarity': self.similarity(curr_text_embeddings[0], curr_text_embeddings[1]),
+                # finding distractor image to target word similarity
+                'multimodal_similarity': self.text_to_images_similarity(curr_image_embeddings, curr_text_embeddings[0], logit_scale=10),
+            })
+        if similarity_scores == []:
+            print(f"skipping {word1} and {word2} since they do not have valid images")
+            return [{
+                'image_similarity': None,
+                'text_similarity': None,
+                'multimodal_similarity': None
+            }]
+        else:
+            return similarity_scores
+        
+    # TODO: probably move this to the dataloader row level instead of to a pair of words within a dataloader row
+    # TODO: words or texts? what is my parameter
+    def embeddings(self, word1, word2, dataloader_row):
+        valid_images = [img for img in dataloader_row['images'] if img is not None]
+        output_embeddings = []
+        for image1, image2 in itertools.combinations(valid_images, 2):
+            curr_image_embeddings = self.image_embeddings([image1, image2])
+            curr_text_embeddings = self.text_embeddings([word1, word2])
+            output_embeddings.append({
+                'image_embeddings': curr_image_embeddings,
+                'text_embeddings': curr_text_embeddings,
+                'multimodal_embeddings': self.multimodal_embeddings(curr_image_embeddings, curr_text_embeddings)
+            })
+        return output_embeddings
+    
+    def save_embedding(self, embedding, curr_id, text, save_path):
+        # if curr_id represents the full path of the image, portion off only the last part
+        if os.path.exists(curr_id):
+            sub_save_path = f"{text}/{Path(curr_id).stem}"
+        else:
+            sub_save_path = curr_id
+        embedding_output_path = Path(f"{os.getcwd()}/{save_path}/{sub_save_path}").with_suffix('.npy')
+        os.makedirs(embedding_output_path.parent, exist_ok=True)
+        np_embedding = embedding.cpu().numpy()
+        np.save(str(embedding_output_path), np_embedding)
+        return str(embedding_output_path)
+    
+    def save_text_embeddings(self, texts, save_path, normalize_embeddings=True, output_type="csv", overwrite=False):
+        filename = f"{self.name}_text_embeddings_{output_type}.csv"
+        text_save_path = os.path.join(str(save_path), "text_embeddings")
+        os.makedirs(text_save_path, exist_ok=True)
+        filepath = os.path.join(text_save_path, filename)
+        existing_row_ids = []
+        if os.path.exists(filepath):
+            existing_df = pd.read_csv(filepath)
+            existing_row_ids = existing_df['row_id'].values
+        # TODO: repeated code -- move embedding code to embeddings folder
+        with torch.no_grad():
+            row_data = []
+            for text in tqdm(texts, desc="Calculating text embeddings"):
+                if text not in existing_row_ids or overwrite:
+                    curr_text_embeddings = self.text_embeddings([text], normalize_embeddings)[0]
+                    curr_row_data = {'row_id': text}
+                    if output_type == "csv":
+                        # new row with a separate column for each number in the 512 dimensions and one for the image_path as the row_id
+                        curr_image_embeddings = curr_image_embeddings.squeeze(0).tolist() if isinstance(curr_image_embeddings, torch.Tensor) else curr_image_embeddings
+                        for i, value in enumerate(curr_image_embeddings):
+                            curr_row_data[f"{i}"] = value.item() if isinstance(value, torch.Tensor) else value
+                    elif output_type == "npy":
+                        curr_row_data["embedding_path"] = self.save_embedding(curr_text_embeddings, text, text, text_save_path)
+                    row_data.append(curr_row_data)
+        if len(row_data) > 0:
+            self.save_df(pd.DataFrame(row_data), filename, text_save_path, overwrite=overwrite)
+
+    def save_image_embeddings(self, save_path=None, normalize_embeddings=True, output_type="csv", overwrite=False):
+        filename = f"{self.name}_image_embeddings_{output_type}.csv"
+        save_path = str(save_path) or os.path.join(os.getcwd(), "output")
+        img_save_path = os.path.join(save_path, "image_embeddings")
+        os.makedirs(img_save_path, exist_ok=True)
+        filepath = os.path.join(img_save_path, filename)
+        existing_row_ids = []
+        if os.path.exists(filepath):
+            existing_df = pd.read_csv(filepath)
+            existing_row_ids = existing_df['row_id'].values
+        all_text = set()
+        with torch.no_grad():
+            for d in tqdm(self.dataloader, desc=f"Calculating {self.name} embeddings", position=tqdm._get_free_pos()):
+                print(d)
+                # TODO: only works for single images in a row
+                row_data = []
+                for count, (image, curr_id, text) in tqdm(enumerate(zip(d['images'], d['id'], d['text'] if d['text'] else itertools.repeat(None, len(d['images'])))), total=len(d['images']), desc="Image embedding progress in current batch", position=tqdm._get_free_pos()):
+                    if curr_id not in existing_row_ids or overwrite:
+                        curr_image_embeddings = self.image_embeddings([image], normalize_embeddings)[0]
+                        curr_row_data = {'row_id': curr_id}
+                        if text is not None:
+                            curr_row_data['text'] = text
+                        if output_type == "csv":
+                            # new row with a separate column for each number in the 512 dimensions and one for the image_path as the row_id
+                            curr_image_embeddings = curr_image_embeddings.squeeze(0).tolist() if isinstance(curr_image_embeddings, torch.Tensor) else curr_image_embeddings
+                            for i, value in enumerate(curr_image_embeddings):
+                                curr_row_data[f"{i}"] = value.item() if isinstance(value, torch.Tensor) else value
+                        elif output_type == "npy":
+                            curr_row_data["embedding_path"] = self.save_embedding(curr_image_embeddings, curr_id, text, img_save_path)
+                        row_data.append(curr_row_data)
+                    if text is not None:
+                        all_text.add(text)
+                if len(row_data) > 0:
+                    self.save_df(pd.DataFrame(row_data), filename, img_save_path, overwrite=overwrite)
+            self.save_text_embeddings(all_text, save_path, normalize_embeddings, output_type, overwrite)
+        
+    def normalize_embeddings(self, embeddings):
+        """Normalize embeddings to unit L2 norm"""
+        return [embedding / embedding.norm(dim=-1, keepdim=True) for embedding in embeddings]
+    

vislearnlabpy-0.0.1.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: vislearnlabpy
+Version: 0.0.1
+Summary: Visual Learning Lab utility files and pipelines
+Author-email: Tarun Sepuri <tarunsepuri@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vislearnlab/vllpy
+Project-URL: Issues, https://github.com/vislearnlab/vllpy/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: pillow>=11.0.0
+Dynamic: license-file
+
+# vllpy
+
+This is a package with common utility functions, files and pipelines for the Visual Learning Lab. Creating a conda environment is recommended but optional. This package uses python=3.12.
+
+```
+conda create -n vislearnlabpy python=3.12
+conda activate vislearnlabpy
+```
+
+Then, activate the environment and simply install vislearnlabpy via running the following pip command in your terminal. You will also have to install [PyTorch](https://pytorch.org/) and CLIP manually.
+
+```
+pip install git+https://github.com/openai/CLIP.git
+pip install --upgrade vislearnlabpy
+```
+
+To install PyTorch on the Tversky server, run:
+```
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+```

vislearnlabpy-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+vislearnlabpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vislearnlabpy/embeddings/embedding_utils.py,sha256=BotVbRg4AEQqxj9HMfcdiEDqzJzNw8dc58W_jdNt484,650
+vislearnlabpy/embeddings/generate_embeddings.py,sha256=HVTTxZqVCEkVGXnKDtmX9AYIoyTfsW_TSFMRqs3Ozz0,1880
+vislearnlabpy/embeddings/stimuli_loader.py,sha256=7vfcjmgdIRrWnDQlLlxEI-pP8IS6z0wp5SLHVaGCsxc,3429
+vislearnlabpy/models/clip_model.py,sha256=c8LWkX1WSezzFliFOaO8ClBKtWCCV36YIdkvjqSqcew,447
+vislearnlabpy/models/feature_generator.py,sha256=VOs_nEimuPJeoLHTLjPdM4MR7zGJtAwADtJENH55ves,4895
+vislearnlabpy/models/multimodal_model.py,sha256=la-ASwoZNvh5BzxiII-1hlvXT7xd5J71fsOcgsBUtho,10718
+vislearnlabpy-0.0.1.dist-info/licenses/LICENSE,sha256=iQFCLVcTzopcVqmTMbKI7LCN_IO0UYBCp7i7ocvwkuQ,1075
+vislearnlabpy-0.0.1.dist-info/METADATA,sha256=gutq1VuFfykQjHJWZQS3p90fWEk0f5AOD8Krtp37Wq4,1327
+vislearnlabpy-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+vislearnlabpy-0.0.1.dist-info/top_level.txt,sha256=3KYf9ks71988SFCQu0HnPY_Q2KRLkWuC09zJRYQOMxs,14
+vislearnlabpy-0.0.1.dist-info/RECORD,,

vislearnlabpy-0.0.1.dist-info/WHEEL

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

vislearnlabpy-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Visual Learning Lab
+
+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.

vislearnlabpy-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+vislearnlabpy