sciveo 0.1.40__tar.gz → 0.1.41__tar.gz

{sciveo-0.1.40 → sciveo-0.1.41}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.40
+Version: 0.1.41
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net
 Provides-Extra: media
 Provides-Extra: media-server
 Provides-Extra: media-ml
-Provides-Extra: media-ml-all
 Provides-Extra: all
 Provides-Extra: media-all
 

{sciveo-0.1.40 → sciveo-0.1.41}/sciveo/media/pipelines/pipeline.py

@@ -81,7 +81,6 @@ class MediaPipeline:
       "image-diffusion": ImageDiffusionText,
       "image-diffusion-image-text": ImageDiffusionImageText,
       "image-to-text": ImageToTextProcessor,
-      "image-query": ImageQueryProcessor,
       "image-fgbg-filter": ImageFGBGFilter,
       "image-segmentation": ImageSegmentation,
       "image-depth-estimation": ImageDepthEstimation,

{sciveo-0.1.40 → sciveo-0.1.41}/sciveo/media/pipelines/processors/image/generators.py

@@ -24,7 +24,7 @@ from sciveo.tools.logger import *
 from sciveo.tools.common import *
 from sciveo.media.pipelines.processors.tpu_base import *
 from sciveo.media.pipelines.base import ApiContent
-from sciveo.ml.images.description import ImageToText, ImageQuery
+from sciveo.ml.images.description import ImageToText
 
 
 class ImageDiffusionText(TPUBaseProcessor):
@@ -202,56 +202,6 @@ class ImageToTextProcessor(TPUBaseProcessor):
     return True
 
 
-class ImageQueryProcessor(TPUBaseProcessor):
-  def __init__(self, processor_config, max_progress) -> None:
-    super().__init__(processor_config, max_progress)
-
-    self.api = ApiContent()
-
-    self.cache_dir = os.path.join(os.environ['MEDIA_MODELS_BASE_PATH'], "models/")
-    self.device = os.environ.get("MEDIA_PROCESSING_BACKEND", "cpu")
-
-    self.default.update({
-      "max_length": 64,
-      "model_id": 0,
-      "query": "describe the image",
-      "output": False
-    })
-
-    self.predictor = None
-
-  def process(self, media):
-    debug("process", media['guid'])
-    if self.predictor is None:
-      self.predictor = ImageQuery(self['query'], self['model_id'], self['max_length'], self.cache_dir, self.device)
-    local_path = media["local_path"]
-    predict = self.predictor.predict_one(local_path)
-    return self.set_media(media, predict)
-
-  def set_media(self, media, predict):
-    media.setdefault("next", [])
-    media["next"].append({
-      "guid": f"TXT-{media['guid']}",
-      "parent": media['guid'],
-      "content_type": "comment",
-      "content_text": predict,
-      "owner": media["owner"],
-      "name": f"{predict} [{self['max_length']}]",
-      "processor": self.name()
-    })
-
-    return media
-
-  def content_type(self):
-    return "image"
-
-  def name(self):
-    return "image-query"
-
-  def is_append_processor(self):
-    return True
-
-
 class ImageDiffusionImageText(TPUBaseProcessor):
   def __init__(self, processor_config, max_progress) -> None:
     super().__init__(processor_config, max_progress)

{sciveo-0.1.40 → sciveo-0.1.41}/sciveo/ml/images/description.py

@@ -33,14 +33,12 @@ class ImageToText(BaseImageML):
     self.models = [
       ["GIT", "softel/git-base-v1.0", "auto"],
       ["GIT", "softel/git-large-v1.0", "auto"],
-      ["CAPTION", "softel/image-instruct-v2.0", "auto"],
       ["BLIP2", "softel/blip2-opt-2.7b-v1.0", torch.float16],
       # ["BLIP2", "softel/blip2-opt-6.7b-v1.0", torch.float16],
     ]
 
     model_config = self.models[model_id]
     self.dtype = model_config[2]
-    self.model_type = model_config[0]
 
     if model_config[0] == "GIT":
       self.pipe = AutoProcessor.from_pretrained(model_config[1], cache_dir=self.cache_dir)
@@ -48,9 +46,6 @@ class ImageToText(BaseImageML):
     elif model_config[0] == "BLIP2":
       self.pipe = Blip2Processor.from_pretrained(model_config[1], cache_dir=self.cache_dir)
       self.model = Blip2ForConditionalGeneration.from_pretrained(model_config[1], torch_dtype=self.dtype, device_map="auto", cache_dir=self.cache_dir)
-    elif model_config[0] == "CAPTION":
-      self.model = AutoModelForCausalLM.from_pretrained(model_config[1], torch_dtype=self.dtype, device_map="auto", cache_dir=self.cache_dir, trust_remote_code=True)
-      self.pipe = self.model
 
     debug("model name", model_config[1], "on device", self.device, "dtype", self.dtype, self.model.dtype)
     self.dtype = self.model.dtype
@@ -58,49 +53,12 @@ class ImageToText(BaseImageML):
   def predict(self, images):
     images = self.load(images)
 
-    if self.model_type == "CAPTION":
-      prediction = []
-      if self.max_length < 64:
-        predict_length = "short"
-      else:
-        predict_length = "normal"
-      for image in images:
-        prediction.append(self.model.caption(image, length=predict_length))
-    else:
-      pixel_values = self.pipe(images=images, return_tensors="pt").pixel_values.to(self.device, self.dtype)
-      ids = self.model.generate(pixel_values=pixel_values, max_length=self.max_length)
-      prediction = self.pipe.batch_decode(ids, skip_special_tokens=True)
+    pixel_values = self.pipe(images=images, return_tensors="pt").pixel_values.to(self.device, self.dtype)
+    ids = self.model.generate(pixel_values=pixel_values, max_length=self.max_length)
+    prediction = self.pipe.batch_decode(ids, skip_special_tokens=True)
 
-      del ids
-      del pixel_values
+    del ids
+    del pixel_values
 
     # debug("image description", prediction)
     return prediction
-
-
-class ImageQuery(BaseImageML):
-  def __init__(self, query, model_id, max_length=64, cache_dir=None, device=None) -> None:
-    super().__init__(model_id, cache_dir, device)
-    self.query = query
-    self.max_length = max_length
-
-    self.models = [
-      ["CAPTION", "softel/image-instruct-v2.0", "auto"],
-      # ["BLIP2", "softel/blip2-opt-2.7b-v1.0", torch.float16],
-      # ["BLIP2", "softel/blip2-opt-6.7b-v1.0", torch.float16],
-    ]
-
-    model_config = self.models[model_id]
-    self.dtype = model_config[2]
-    self.model_type = model_config[0]
-
-    if model_config[0] == "CAPTION":
-      self.model = AutoModelForCausalLM.from_pretrained(model_config[1], torch_dtype=self.dtype, device_map="auto", cache_dir=self.cache_dir, trust_remote_code=True)
-      self.pipe = self.model
-
-    debug("model name", model_config[1], "on device", self.device, "dtype", self.dtype, self.model.dtype)
-    self.dtype = self.model.dtype
-
-  def predict_one(self, x):
-    image = self.load_image(x)
-    return self.model.query(image, self.query)["answer"]

sciveo-0.1.41/sciveo/ml/images/segmentation.py

@@ -0,0 +1,304 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2024
+#
+
+import os
+import threading
+import cv2
+from PIL import Image
+import json
+import numpy as np
+
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+import torch
+import transformers
+import torchvision
+
+from transformers import AutoImageProcessor, MaskFormerForInstanceSegmentation
+
+
+class ImageTilesSplit:
+  def __init__(self, image, name):
+    self.image = image
+    self.name = name
+
+  def split(self, tile_size=(640, 640)):
+    if self.image.shape[2] > 1:
+        original_image = Image.fromarray(cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB))
+    else:
+        original_image = Image.fromarray(self.image)
+    original_width, original_height = original_image.size
+
+    num_tiles_x = (original_width + tile_size[0] - 1) // tile_size[0]
+    num_tiles_y = (original_height + tile_size[1] - 1) // tile_size[1]
+
+    self.tiles_info = {
+        'image': self.image,
+        'original_image': original_image,
+        'original_size': (original_width, original_height),
+        'tile_size': tile_size,
+        'num_tiles_x': num_tiles_x,
+        'num_tiles_y': num_tiles_y,
+        'tiles': {}
+    }
+
+    for i in range(num_tiles_x):
+      for j in range(num_tiles_y):
+        left = i * tile_size[0]
+        upper = j * tile_size[1]
+        right = min(left + tile_size[0], original_width)
+        lower = min(upper + tile_size[1], original_height)
+
+        tile = original_image.crop((left, upper, right, lower))
+
+        tile_key = f'tile_{i}_{j}'
+        self.tiles_info['tiles'][tile_key] = {
+          'position': (i, j),
+          'box': (left, upper, right, lower),
+          'tile': tile,
+          # 'cv2.tile': cv2.cvtColor(np.array(tile), cv2.COLOR_RGB2BGR)
+          'cv2.tile': np.array(tile)
+        }
+
+    return self.tiles_info
+
+  def join(self, tile_join_key="predicted"):
+    joined = np.zeros((self.tiles_info['original_size'][1], self.tiles_info['original_size'][0], 1), dtype=np.uint8)
+    for tile_key, tile_info in self.tiles_info['tiles'].items():
+      box = tile_info['box']
+      joined[box[1]:box[3], box[0]:box[2], 0] = tile_info[tile_join_key]
+    joined = np.squeeze(joined, axis=-1)
+    self.tiles_info[tile_join_key] = joined
+    return joined
+
+  def get_original_coordinates(self, tile_key, x, y):
+    """
+    Converts coordinates from a tile back to the original image.
+
+    Args:
+        tile_key (str): The key of the tile in the tiles_info dictionary.
+        x (int): The x-coordinate in the tile.
+        y (int): The y-coordinate in the tile.
+
+    Returns:
+        tuple: The coordinates (x_original, y_original) in the original image.
+    """
+    tile_data = self.tiles_info['tiles'][tile_key]
+    left, upper, _, _ = tile_data['box']
+
+    x_original = left + x
+    y_original = upper + y
+
+    return (x_original, y_original)
+
+  def plot_tiles_with_grid(self):
+    original_width, original_height = self.tiles_info['original_size']
+    tile_width, tile_height = self.tiles_info['tile_size']
+    num_tiles_x = self.tiles_info['num_tiles_x']
+    num_tiles_y = self.tiles_info['num_tiles_y']
+
+    fig, ax = plt.subplots(figsize=(10, 10))
+
+    ax.imshow(self.tiles_info['original_image'])
+
+    for i in range(num_tiles_x + 1):
+        x = i * tile_width
+        ax.axvline(x=x, color='r', linestyle='--', linewidth=1)
+
+    for j in range(num_tiles_y + 1):
+        y = j * tile_height
+        ax.axhline(y=y, color='r', linestyle='--', linewidth=1)
+
+    ax.set_xlim(0, original_width)
+    ax.set_ylim(original_height, 0)
+
+    for i in range(num_tiles_x):
+        for j in range(num_tiles_y):
+            x_center = i * tile_width + tile_width / 2
+            y_center = j * tile_height + tile_height / 2
+            ax.text(x_center, y_center, f'{i},{j}', color=(0,1,0), fontsize=7, ha='center', va='center')
+
+    plt.title(f"{self.name} Grid")
+    plt.xlabel("X")
+    plt.ylabel("Y")
+    plt.show()
+
+  def plot_tiles_individually(self):
+    num_tiles_x = self.tiles_info['num_tiles_x']
+    num_tiles_y = self.tiles_info['num_tiles_y']
+
+    fig, axes = plt.subplots(num_tiles_y, num_tiles_x, figsize=(15, 15))
+
+    if num_tiles_x == 1 and num_tiles_y == 1:
+        axes = [[axes]]
+    elif num_tiles_x == 1:
+        axes = [[ax] for ax in axes]
+    elif num_tiles_y == 1:
+        axes = [axes]
+
+    for i in range(num_tiles_x):
+        for j in range(num_tiles_y):
+            tile_key = f'tile_{i}_{j}'
+            tile = self.tiles_info['tiles'][tile_key]['tile']
+
+            ax = axes[j][i]
+
+            ax.imshow(tile, cmap='gray')
+            ax.set_title(f'{i}.{j}', fontsize=8)
+            ax.axis('off')
+
+    plt.tight_layout()
+    plt.show()
+
+
+class MaskInstancePredictor:
+  def __init__(self, cache_dir, device="cuda", colors=None):
+    if colors is None:
+      self.colors = [
+        [0, 0, 255],
+        [0, 255, 0],
+        [255, 0, 0],
+        [255, 255, 255]
+      ]
+    else:
+      self.colors = colors
+
+    self.device = device
+    self.cache_dir = cache_dir
+
+    self.processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade")
+    self.model = MaskFormerForInstanceSegmentation.from_pretrained(
+      "facebook/maskformer-swin-base-ade",
+      cache_dir=cache_dir
+    ).to(self.device)
+
+  def relabel_predictions(self, predictions, label_map, new_labels):
+    relabeled = np.full_like(predictions, fill_value=-1)
+
+    for label_id, label_name in label_map.items():
+      if label_name in new_labels:
+        relabeled[predictions == label_id] = new_labels[label_name]
+
+    return relabeled
+
+  def predict_one(self, image):
+    inputs = self.processor(images=image, return_tensors="pt").to(self.device)
+    with torch.no_grad():
+      outputs = self.model(**inputs)
+
+    predicted = self.processor.post_process_semantic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]
+    return predicted.to("cpu")
+
+  def plot_mask(self, image, mask, alpha=0.5):
+    color_mask = np.zeros((mask.shape[0], mask.shape[1], 3), dtype=np.uint8) # height, width, 3
+    for label, color in enumerate(self.colors):
+      color_mask[mask == label, :] = color
+    color_mask = color_mask[..., ::-1] # Convert to BGR
+
+    masked_image = np.array(image) * (1 - alpha) + color_mask * alpha
+    masked_image = masked_image.astype(np.uint8)
+
+    plt.figure(figsize=(15, 10))
+    plt.imshow(masked_image)
+    plt.show()
+
+
+class UrbanPredictor:
+  def __init__(self, name, cache_dir, device="cuda"):
+    self.name = name
+    self.device = device
+    self.cache_dir = cache_dir
+
+    self.predictor = MaskInstancePredictor(cache_dir, device=device)
+    self._classes = {"artificial": 0, "natural": 1}
+    self.ade_classes = {
+      0: 'artificial', 1: 'artificial', 2: 'natural', 3: 'artificial', 4: 'natural', 5: 'artificial',6: 'artificial',7: 'artificial',8: 'artificial',9: 'natural',
+      10: 'artificial',11: 'artificial',12: 'artificial',13: 'natural',14: 'artificial',15: 'artificial',16: 'natural',17: 'natural',18: 'artificial',19: 'artificial',
+      20: 'artificial',21: 'natural',22: 'artificial',23: 'artificial',24: 'artificial',25: 'artificial',26: 'natural',27: 'artificial',28: 'artificial',29: 'natural',
+      30: 'artificial',31: 'artificial',32: 'artificial',33: 'artificial',34: 'natural',35: 'artificial',36: 'artificial',37: 'artificial',38: 'artificial',39: 'artificial',
+      40: 'artificial',41: 'artificial',42: 'artificial',43: 'artificial',44: 'artificial',45: 'artificial',46: 'natural',47: 'artificial',48: 'artificial',49: 'artificial',
+      50: 'artificial',51: 'artificial',52: 'artificial',53: 'artificial',54: 'artificial',55: 'artificial',56: 'artificial',57: 'artificial',58: 'artificial',59: 'artificial',
+      60: 'natural',61: 'artificial',62: 'artificial', 63: 'artificial', 64: 'artificial',65: 'artificial',66: 'natural',67: 'artificial',68: 'natural',69: 'artificial',
+      70: 'artificial',71: 'artificial',72: 'natural',73: 'artificial',74: 'artificial',75: 'artificial',76: 'artificial',77: 'artificial',78: 'artificial',79: 'artificial',
+      80: 'artificial',81: 'artificial',82: 'artificial',83: 'artificial',84: 'artificial',85: 'artificial',86: 'artificial',87: 'artificial',88: 'artificial',89: 'artificial',
+      90: 'artificial',91: 'artificial',92: 'artificial',93: 'artificial',94: 'natural',95: 'artificial',96: 'artificial',97: 'artificial',98: 'artificial',99: 'artificial',
+      100: 'artificial',101: 'artificial',102: 'artificial',103: 'artificial',104: 'artificial',105: 'artificial',106: 'artificial',107: 'artificial',108: 'artificial',109: 'artificial',
+      110: 'artificial',111: 'artificial',112: 'artificial',113: 'natural',114: 'artificial',115: 'artificial',116: 'artificial',117: 'artificial',118: 'artificial',119: 'artificial',
+      120: 'artificial',121: 'artificial',122: 'artificial',123: 'artificial',124: 'artificial',125: 'artificial',126: 'natural',127: 'artificial',128: 'natural',129: 'artificial',
+      130: 'artificial',131: 'artificial',132: 'artificial',133: 'artificial',134: 'artificial',135: 'artificial',136: 'artificial',137: 'artificial',138: 'artificial',139: 'artificial',
+      140: 'artificial',141: 'artificial',142: 'artificial',143: 'artificial',144: 'artificial',145: 'artificial',146: 'artificial',147: 'artificial',148: 'artificial',149: 'artificial'
+      }
+    # natural_labels = {
+    #   'sky', 'tree', 'grass', 'mountain, mount', 'plant', 'water', 'earth, ground',
+    #   'rock, stone', 'sand', 'flower', 'hill', 'palm, palm tree', 'river', 'sea',
+    #   'field', 'land, ground, soil', 'falls', 'lake', 'animal'
+    # }
+    # self.ade_classes = {
+    #   key: "natural" if value in natural_labels else "artificial"
+    #   for key, value in self.predictor.model.config.id2label.items()
+    # }
+
+  def predict(self, image, w=512):
+    self.tile_split = ImageTilesSplit(image, name=self.name)
+    self.tile_split.split(tile_size=(w, w))
+
+    n = 1
+    l = len(self.tile_split.tiles_info['tiles'])
+    for tile_key, tile_info in self.tile_split.tiles_info['tiles'].items():
+      mask = self.predictor.predict_one(tile_info['tile'])
+      mask = self.predictor.relabel_predictions(mask, self.ade_classes, self._classes)
+      self.tile_split.tiles_info['tiles'][tile_key]['predicted'] = mask
+      if n % 100 == 0:
+          info(f"predict {self.name}", f"{n}/{l}", f"on {self.device}")
+      n += 1
+
+    self.tile_split.join(tile_join_key="predicted")
+
+  def plot(self, alpha=0.5):
+    self.predictor.plot_mask(self.tile_split.tiles_info['image'], self.tile_split.tiles_info['predicted'], alpha=alpha)
+
+  def plot_tile(self, tile_key, alpha=0.5):
+    self.predictor.plot_mask(self.tile_split.tiles_info['tiles'][tile_key]['tile'], self.tile_split.tiles_info['tiles'][tile_key]['predicted'], alpha=alpha)
+
+
+class ThrPredictor:
+  plot_lock = threading.Lock()
+
+  def __init__(self, name, base_path, w, cache_dir, device):
+    self.image = cv2.imread(os.path.join(base_path, name))
+    self.name = name
+    self.w = w
+    self.cache_dir = cache_dir
+    self.device = device
+
+  def start(self):
+    self.t = threading.Thread(target = self.run)
+    self.t.start()
+
+  def join(self):
+    self.t.join()
+
+  def plot(self, alpha=0.3):
+    info("Plot", self.name)
+    self.predictor.tile_split.plot_tiles_with_grid()
+    self.predictor.plot(alpha=alpha)
+    # self.predictor.plot_tile("tile_11_11", alpha=alpha)
+
+  def run(self):
+    try:
+      self.predictor = UrbanPredictor(name=self.name, cache_dir=self.cache_dir, device=self.device)
+      self.predictor.predict(self.image, w=self.w)
+      with ThrPredictor.plot_lock:
+        self.plot(alpha=0.3)
+    except Exception as e:
+      error(e)

{sciveo-0.1.40 → sciveo-0.1.41}/sciveo/ml/nlp/embeddings.py

@@ -23,6 +23,7 @@ import numpy as np
 import pandas as pd
 
 from transformers import AutoTokenizer, AutoModel
+from sentence_transformers import SentenceTransformer
 
 from sciveo.tools.logger import *
 from sciveo.ml.base import BaseML
@@ -128,3 +129,24 @@ class TextEmbedding(BaseML):
         embedding = embedding.tolist()
       predictions.append(embedding)
     return predictions
+
+
+class SentenceEmbedding(TextEmbedding):
+  def __init__(self, model_name='BAAI/bge-m3', cache_dir=None, device=None) -> None:
+    super().__init__(model_name=model_name, cache_dir=cache_dir, device=device)
+    self.model = None
+    self.max_tokens = 8192
+    self.normalize_embeddings = True
+
+  def init(self):
+    if self.model is None:
+      self.model = SentenceTransformer(self.model_name).to(self.device)
+      self.post_init()
+
+  def predict_one(self, x):
+    return self.predict([x])[0]
+
+  def predict(self, X):
+    self.init()
+    predictions = self.model.encode(X, normalize_embeddings=self.normalize_embeddings)
+    return predictions.detach().numpy()

sciveo-0.1.41/sciveo/version.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.1.41'

{sciveo-0.1.40 → sciveo-0.1.41}/sciveo.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.40
+Version: 0.1.41
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net
 Provides-Extra: media
 Provides-Extra: media-server
 Provides-Extra: media-ml
-Provides-Extra: media-ml-all
 Provides-Extra: all
 Provides-Extra: media-all
 

{sciveo-0.1.40 → sciveo-0.1.41}/sciveo.egg-info/SOURCES.txt

@@ -96,6 +96,7 @@ sciveo/ml/images/base.py
 sciveo/ml/images/description.py
 sciveo/ml/images/embeddings.py
 sciveo/ml/images/object_detection.py
+sciveo/ml/images/segmentation.py
 sciveo/ml/images/tools.py
 sciveo/ml/images/transformers.py
 sciveo/ml/nlp/__init__.py

{sciveo-0.1.40 → sciveo-0.1.41}/sciveo.egg-info/requires.txt

@@ -54,6 +54,7 @@ torch>=0.0.0
 torchvision>=0.0.0
 diffusers>=0.0.0
 transformers>=0.0.0
+sentence_transformers>=0.0.0
 accelerate>=0.0.0
 annoy>=0.0.0
 ultralytics>=0.0.0
@@ -65,14 +66,11 @@ torch>=0.0.0
 torchvision>=0.0.0
 diffusers>=0.0.0
 transformers>=0.0.0
+sentence_transformers>=0.0.0
 accelerate>=0.0.0
 annoy>=0.0.0
 ultralytics>=0.0.0
 
-[media-ml-all]
-pyvips>=0.0.0
-einops>=0.0.0
-
 [media-server]
 fastapi
 uvicorn[standard]

{sciveo-0.1.40 → sciveo-0.1.41}/setup.py

@@ -29,12 +29,8 @@ extras_require = {
       'media-ml': [
         'tensorflow>=0.0.0', 'keras>=0.0.0',
         'torch>=0.0.0', 'torchvision>=0.0.0',
-        'diffusers>=0.0.0', 'transformers>=0.0.0', 'accelerate>=0.0.0', 'annoy>=0.0.0',
-        'ultralytics>=0.0.0',
-      ],
-      'media-ml-all': [
-        'pyvips>=0.0.0',
-        'einops>=0.0.0'
+        'diffusers>=0.0.0', 'transformers>=0.0.0', 'sentence_transformers>=0.0.0', 'accelerate>=0.0.0', 'annoy>=0.0.0',
+        'ultralytics>=0.0.0'
       ]
 }
 

sciveo-0.1.40/sciveo/version.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.1.40'