sciveo 0.1.35__tar.gz → 0.1.38__tar.gz

{sciveo-0.1.35 → sciveo-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.35
+Version: 0.1.38
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

{sciveo-0.1.35 → sciveo-0.1.38}/sciveo/media/pipelines/base.py

@@ -35,7 +35,7 @@ class BaseContentProcessor:
     k = k.replace(".MOV", e)
     return k
 
-  def next_content(self, media, tag=None, local_path=None, content_type=None, key=None, w=100, h=100, name=""):
+  def next_content(self, media, tag=None, local_path=None, content_type=None, key=None, w=100, h=100, name="", args={}):
     if content_type is None:
       content_type = media['content_type']
     if key is None:
@@ -53,7 +53,7 @@ class BaseContentProcessor:
 
     media.setdefault("next", [])
 
-    media["next"].append({
+    media["next"].append(dict({
       "guid": guid,
       "content_type": content_type,
       "name": name,
@@ -67,7 +67,7 @@ class BaseContentProcessor:
       "processor": self.name(),
       "processors": media["processors"],
       "layout": {"name": self.name(), **self["layout"]}
-    })
+    }, **args))
 
   def content_type(self):
     return "media"

{sciveo-0.1.35 → sciveo-0.1.38}/sciveo/media/pipelines/processors/image/embeddings.py

@@ -21,7 +21,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.nlp.images.embeddings import ImageEmbedding
+from sciveo.ml.images.embeddings import ImageEmbedding
 
 
 class ImageEmbeddingProcessor(TPUBaseProcessor):

sciveo-0.1.38/sciveo/media/pipelines/processors/image/object_detection.py

@@ -0,0 +1,81 @@
+#
+# 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 numpy as np
+import cv2
+
+from sciveo.tools.logger import *
+from sciveo.tools.simple_counter import Timer
+from sciveo.tools.common import *
+from sciveo.ml.images.object_detection import ObjectDetectorYOLO
+from sciveo.media.pipelines.processors.base import *
+
+
+class ImageObjectDetectionProcessor(BaseProcessor):
+  def __init__(self, processor_config, max_progress) -> None:
+    super().__init__(processor_config, max_progress)
+    self.default.update({"JPEG_QUALITY": 80, "min_confidence": 0.5, "model_type": 0, "height": 720})
+
+  def init_run(self):
+    self.predictor = ObjectDetectorYOLO(model_path=[
+      "yolo11x.pt", "yolo11l.pt", "yolo11m.pt", "yolo11s.pt", "yolo11n.pt",
+      'softel-surveillance-yolo11X.pt', 'softel-surveillance-yolo11L.pt', 'softel-surveillance-yolo11M.pt',
+      'softel-surveillance-yolo11S.pt', 'softel-surveillance-yolo11N.pt',
+    ][self["model_type"]])
+
+  def process(self, media):
+    try:
+      self.media = media
+      self.local_path = media["local_path"]
+
+      tag = "object-detections"
+      image = self.predictor.load(self.local_path)
+
+      image_resized = self.predictor.resize(image)
+      detections = self.predictor.predict_one([image_resized], confidence_threshold=self["min_confidence"])
+
+      image_resized = self.predictor.resize(image, h=self["height"])
+      image_resized = cv2.cvtColor(image_resized, cv2.COLOR_RGB2BGR)
+      self.predictor.draw(image_resized, detections[0])
+      result_image_local_path = self.add_suffix_to_filename(self.local_path, tag)
+      cv2.imwrite(result_image_local_path, image_resized, [cv2.IMWRITE_JPEG_QUALITY, self["JPEG_QUALITY"]])
+
+      self.next_content(self.media, tag, result_image_local_path, w=image_resized.shape[1], h=image_resized.shape[0])
+      self.next_comment(detections[0])
+    except Exception as e:
+      exception(e, self.media)
+    return self.media
+
+  def next_comment(self, detections):
+    boxes = detections.boxes
+    class_names = detections.names
+    detections_json = {}
+    for i, box in enumerate(boxes):
+      confidence = box.conf[0].item()
+      class_id = int(box.cls[0].item())
+      label = class_names[class_id]
+      detections_json.setdefault(label, 0)
+      detections_json[label] += 1
+
+    detections_str = ""
+    for k, v in detections_json.items():
+      detections_str += f"{v} {k}\n"
+
+    self.next_content(self.media, tag="OD", content_type="comment", name=f"OD {self.predictor.model_name}", args={
+      "description": detections_str,
+      "content_text": f"{detections_str}\n\n{str(detections_json)}"
+    })
+
+  def content_type(self):
+    return "image"
+
+  def name(self):
+    return "image-object-detection"

{sciveo-0.1.35 → sciveo-0.1.38}/sciveo/ml/images/embeddings.py

@@ -95,6 +95,8 @@ class ImageEmbedding(BaseImageML):
     self.init()
     predictions = []
     for current_x in X:
-      embedding = self.predict_one(current_x).tolist()
+      embedding = self.predict_one(current_x)
+      if not isinstance(embedding, list):
+        embedding = embedding.tolist()
       predictions.append(embedding)
     return predictions

{sciveo-0.1.35/sciveo/media/pipelines/processors/image → sciveo-0.1.38/sciveo/ml/images}/object_detection.py

@@ -9,19 +9,103 @@
 # 2024
 #
 
+import os
+import boto3
+import math
 import numpy as np
 import cv2
 
+from sciveo.ml.images.tools import *
+from sciveo.ml.base import BaseML
 from sciveo.tools.logger import *
-from sciveo.tools.simple_counter import Timer
-from sciveo.tools.common import *
-from sciveo.media.pipelines.processors.base import *
 
 
-class ObjectDetectorBase:
-  def __init__(self, model_path, device='cpu', colors=None):
+"""
+Object Detection Bounding Boxes (bbox) of type [x, y, w, h]
+
+If need to use [x1, y1, x2, y2] need to use the inverted convertor bbox_convert_inverted().
+
+IoU between 2 object detections: iou(bbox1, bbox2)
+
+"""
+
+# convert from [x, y, w, h] -> [x1, y1, x2, y2]
+def bbox_convert(bbox):
+  x1 = bbox[0]
+  y1 = bbox[1]
+  x2 = x1 + bbox[2]
+  y2 = y1 + bbox[3]
+  return [x1, y1, x2, y2]
+
+# convert from [x1, y1, x2, y2] -> [x, y, w, h]
+def bbox_convert_inverted(bbox):
+  x = bbox[0]
+  y = bbox[1]
+  w = bbox[2] - x
+  h = bbox[3] - y
+  return [x, y, w, h]
+
+def bbox_norm(bbox, w, h):
+  return (bbox[0] / w, bbox[1] / h, bbox[2] / w, bbox[3] / h)
+
+def bbox_denorm(bbox, w, h):
+  return (int(bbox[0] * w), int(bbox[1] * h), int(bbox[2] * w), int(bbox[3] * h))
+
+def bbox_center(bbox):
+  return (int(bbox[0] + bbox[2] / 2), int(bbox[1] + bbox[3] / 2))
+
+def bbox_area(bbox):
+  return bbox[2] * bbox[3]
+
+def iou(bbox1, bbox2):
+  x1 = max(bbox1[0], bbox2[0])
+  y1 = max(bbox1[1], bbox2[1])
+  x2 = min(bbox1[0] + bbox1[2], bbox2[0] + bbox2[2])
+  y2 = min(bbox1[1] + bbox1[3], bbox2[1] + bbox2[3])
+
+  if x1 < x2 and y1 < y2:
+    a = (x2 - x1) * (y2 - y1)
+  else:
+    a = 0
+
+  a1 = bbox_area(bbox1)
+  a2 = bbox_area(bbox2)
+  return a / (a1 + a2 - a)
+
+def bbox_distance(bbox1, bbox2):
+  return points_distance(bbox_center(bbox1), bbox_center(bbox2))
+
+
+"""
+
+Simple Draw object detectios helpers
+
+"""
+def image_shape(image):
+  return image.shape[1], image.shape[0]
+
+# Draw label bounding boxes of type [x, y, w, h], if [x1, y1, x2, y2] then set convert=False
+def draw_label_bboxes(image, bboxes, color, convert=True):
+  w, h = image_shape(image)
+  for bbox in bboxes:
+    if convert:
+      bbox = bbox_convert(bbox)
+    bbox = bbox_denorm(bbox, w, h)
+    cv2.rectangle(image, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color, 2, 1)
+  return image
+
+
+"""
+
+Object Detectors
+
+"""
+
+class ObjectDetectorBase(BaseML):
+  def __init__(self, model_path, cache_dir=None, device='cpu', colors=None):
+    super().__init__(model_path, cache_dir=cache_dir, device=device)
     self.model_path = model_path
-    self.device = device
+
     if colors is None:
       self.colors = [
         (60, 180, 75),    # Green
@@ -99,9 +183,18 @@ class ObjectDetectorBase:
 
 
 class ObjectDetectorYOLO(ObjectDetectorBase):
-  def __init__(self, model_path="yolo11m.pt", device='cpu', colors=None):
-    super().__init__(model_path, device=device, colors=colors)
+  def __init__(self, model_path="yolo11m.pt", cache_dir=None, device='cpu', colors=None):
+    super().__init__(model_path, cache_dir=cache_dir, device=device, colors=colors)
     from ultralytics import YOLO
+    if self.model_name.startswith("softel"):
+      self.model_path = os.path.join(self.cache_dir, self.model_name.replace("/", "---"))
+      if os.path.isfile(self.model_path):
+        debug(self.model_name, "available", self.model_path)
+      else:
+        debug("DWN", self.model_name)
+        s3 = boto3.client('s3')
+        s3.download_file("sciveo-model", self.model_name, self.model_path)
+
     self.model = YOLO(self.model_path)
 
   def predict_one(self, x, confidence_threshold=0.5):
@@ -127,8 +220,8 @@ class ObjectDetectorYOLO(ObjectDetectorBase):
 
     return predictions
 
-  def resize(self, image):
-    return super().resize(image, 640)
+  def resize(self, image, h=640):
+    return super().resize(image, h)
 
   def draw(self, image, detections, colors=None):
     if colors is None:
@@ -146,41 +239,3 @@ class ObjectDetectorYOLO(ObjectDetectorBase):
 
       color = colors[i % len(colors)]
       self.draw_object_rectangle_xyxy(image, bbox, label_text, color)
-
-
-class ImageObjectDetectionProcessor(BaseProcessor):
-  def __init__(self, processor_config, max_progress) -> None:
-    super().__init__(processor_config, max_progress)
-    self.default.update({"JPEG_QUALITY": 80, "min_confidence": 0.5, "model_type": 0, "height": 720})
-
-  def init_run(self):
-    TPU = os.environ.get("MEDIA_PROCESSING_BACKEND", "cpu")
-    self.predictor = ObjectDetectorYOLO(model_path=["yolo11x.pt", "yolo11l.pt", "yolo11m.pt", "yolo11s.pt"][self["model_type"]], device=TPU)
-
-  def process(self, media):
-    try:
-      self.media = media
-      self.local_path = media["local_path"]
-
-      tag = "object-detections"
-      image = self.predictor.load(self.local_path)
-      image_resized = self.predictor.resize(image)
-
-      detections = self.predictor.predict_one([image_resized], confidence_threshold=self["min_confidence"])
-
-      # image_resized = self.predictor.super().resize(image, h=self["height"])
-      image_resized = cv2.cvtColor(image_resized, cv2.COLOR_RGB2BGR)
-      self.predictor.draw(image_resized, detections[0])
-      result_image_local_path = self.add_suffix_to_filename(self.local_path, tag)
-      cv2.imwrite(result_image_local_path, image_resized, [cv2.IMWRITE_JPEG_QUALITY, self["JPEG_QUALITY"]])
-
-      self.next_content(self.media, tag, result_image_local_path, w=image_resized.shape[1], h=image_resized.shape[0])
-    except Exception as e:
-      exception(e, self.media)
-    return self.media
-
-  def content_type(self):
-    return "image"
-
-  def name(self):
-    return "image-object-detection"

sciveo-0.1.35/sciveo/ml/images/transforms.py → sciveo-0.1.38/sciveo/ml/images/transformers.py

@@ -17,11 +17,11 @@ class BaseImageTransformer:
   def __init__(self, param=0):
     self.param = param
 
-  def result(self, image, labels):
-    if labels is None:
-      return image
-    else:
-      return image, labels
+  def __call__(self, image, labels=None):
+    return image, labels
+
+  def transform(self, image, labels=None):
+    return self(image, labels)
 
 
 class RandomTransformer(BaseImageTransformer):
@@ -38,7 +38,7 @@ class RandomTransformer(BaseImageTransformer):
       self.transformer.param = np.random.uniform(self.lower, self.upper)
       return self.transformer(image, labels)
     else:
-      return self.result(image, labels)
+      return image, labels
 
 
 class ConvertColor(BaseImageTransformer):
@@ -61,20 +61,19 @@ class ConvertColor(BaseImageTransformer):
       image = cv2.cvtColor(image, cv2.COLOR_HSV2GRAY)
       if self.keep_3ch:
         image = np.stack([image] * 3, axis=-1)
-    return self.result(image, labels)
+    return image, labels
 
 
 class ConvertDataType(BaseImageTransformer):
-  def __init__(self, to='uint8'):
-    if not (to == 'uint8' or to == 'float32'): raise ValueError("uint8 or float32 only")
+  def __init__(self, to=np.uint8):
     self.to = to
 
   def __call__(self, image, labels=None):
-    if self.to == 'uint8':
-      image = np.round(image, decimals=0).astype(np.uint8)
+    if self.to == np.uint8:
+      image = np.round(image, decimals=0).astype(self.to)
     else:
       image = image.astype(np.float32)
-    return self.result(image, labels)
+    return image, labels
 
 
 class ConvertTo3Channels(BaseImageTransformer):
@@ -89,27 +88,29 @@ class ConvertTo3Channels(BaseImageTransformer):
         image = np.concatenate([image] * 3, axis=-1)
       elif image.shape[2] == 4:
         image = image[:,:,:3]
-    return self.result(image, labels)
+    return image, labels
 
 
 class Hue(BaseImageTransformer):
   def __init__(self, delta):
-    if not (-180 <= delta <= 180): raise ValueError("delta shoulbe in [-180, 180]")
+    if not (-180 <= delta <= 180):
+      delta = 0
     super().__init__(delta)
 
   def __call__(self, image, labels=None):
     image[:, :, 0] = (image[:, :, 0] + self.param) % 180.0
-    return self.result(image, labels)
+    return image, labels
 
 
 class Saturation(BaseImageTransformer):
   def __init__(self, factor):
-    if factor <= 0.0: raise ValueError("It must be `factor > 0`.")
+    if factor <= 0.0:
+      factor = 1e-10
     super().__init__(factor)
 
   def __call__(self, image, labels=None):
     image[:,:,1] = np.clip(image[:,:,1] * self.param, 0, 255)
-    return self.result(image, labels)
+    return image, labels
 
 
 class Brightness(BaseImageTransformer):
@@ -118,7 +119,7 @@ class Brightness(BaseImageTransformer):
 
   def __call__(self, image, labels=None):
     image = np.clip(image + self.param, 0, 255)
-    return self.result(image, labels)
+    return image, labels
 
 
 class Contrast(BaseImageTransformer):
@@ -128,7 +129,7 @@ class Contrast(BaseImageTransformer):
 
   def __call__(self, image, labels=None):
     image = np.clip(127.5 + self.param * (image - 127.5), 0, 255)
-    return self.result(image, labels)
+    return image, labels
 
 
 class Gamma(BaseImageTransformer):
@@ -140,7 +141,7 @@ class Gamma(BaseImageTransformer):
 
   def __call__(self, image, labels=None):
     image = cv2.LUT(image, self.lut)
-    return self.result(image, labels)
+    return image, labels
 
 
 class RandomGamma(BaseImageTransformer):
@@ -157,7 +158,7 @@ class RandomGamma(BaseImageTransformer):
       change_gamma = Gamma(gamma=gamma)
       return change_gamma(image, labels)
     else:
-      return self.result(image, labels)
+      return image, labels
 
 
 class HistogramEqualization(BaseImageTransformer):
@@ -166,7 +167,7 @@ class HistogramEqualization(BaseImageTransformer):
 
   def __call__(self, image, labels=None):
     image[:,:,2] = cv2.equalizeHist(image[:,:,2])
-    return self.result(image, labels)
+    return image, labels
 
 
 class RandomHistogramEqualization(BaseImageTransformer):
@@ -179,7 +180,7 @@ class RandomHistogramEqualization(BaseImageTransformer):
     if p >= (1.0-self.prob):
       return self.equalize(image, labels)
     else:
-      return self.result(image, labels)
+      return image, labels
 
 
 class ChannelSwap(BaseImageTransformer):
@@ -188,7 +189,7 @@ class ChannelSwap(BaseImageTransformer):
 
   def __call__(self, image, labels=None):
     image = image[:,:,self.order]
-    return self.result(image, labels)
+    return image, labels
 
 
 class RandomChannelSwap(BaseImageTransformer):
@@ -204,7 +205,7 @@ class RandomChannelSwap(BaseImageTransformer):
       self.swap_channels.order = self.permutations[i]
       return self.swap_channels(image, labels)
     else:
-      return self.result(image, labels)
+      return image, labels
 
 
 class BlackWhite(BaseImageTransformer):
@@ -213,7 +214,7 @@ class BlackWhite(BaseImageTransformer):
 
   def __call__(self, image, labels=None):
     image = np.transpose(np.tile(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), (3, 1, 1)), [1, 2, 0])
-    return self.result(image, labels)
+    return image, labels
 
 
 class GaussianNoise(BaseImageTransformer):
@@ -235,7 +236,7 @@ class GaussianNoise(BaseImageTransformer):
     image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX, dtype=-1)
     image = image.astype(np.uint8)
 
-    return self.result(image, labels)
+    return image, labels
 
 
 class Pixelisator(BaseImageTransformer):
@@ -248,7 +249,7 @@ class Pixelisator(BaseImageTransformer):
     k = 1.0 / self.param
     image = cv2.resize(image, (int(w * k), int(h * k)))
     image = cv2.resize(image, (w, h))
-    return self.result(image, labels)
+    return image, labels
 
 
 class Blur(BaseImageTransformer):
@@ -257,4 +258,59 @@ class Blur(BaseImageTransformer):
 
   def __call__(self, image, labels=None):
     image = cv2.blur(image, (int(self.param), int(self.param)))
-    return self.result(image, labels)
+    return image, labels
+
+
+class PhotometricTransformer:
+  def __init__(self):
+    self.sequences = [
+                      [
+                        ConvertTo3Channels(),
+                        RandomTransformer(Brightness, lower=-32, upper=32, proba=0.5),
+                        ConvertDataType(to=np.float32),
+                        RandomTransformer(Contrast, lower=0.5, upper=1.5, proba=0.5),
+                        ConvertDataType(to=np.uint8),
+                        RandomTransformer(BlackWhite, lower=0, upper=0, proba=0.2),
+                        RandomTransformer(GaussianNoise, lower=32, upper=256, proba=0.2),
+                        RandomTransformer(Pixelisator, lower=1.0, upper=3.0, proba=0.2),
+                        RandomTransformer(Blur, lower=2.0, upper=10.0, proba=0.2),
+                        ConvertColor(current='RGB', to='HSV'),
+                        ConvertDataType(to=np.float32),
+                        RandomTransformer(Saturation, lower=0.5, upper=1.5, proba=0.5),
+                        RandomTransformer(Hue, lower=-18, upper=18, proba=0.5),
+                        ConvertDataType(to=np.uint8),
+                        ConvertColor(current='HSV', to='RGB'),
+                        RandomChannelSwap(prob=0.0)
+                      ],
+                      [
+                        ConvertTo3Channels(),
+                        ConvertDataType(to=np.uint8),
+                        RandomTransformer(Brightness, lower=-64, upper=64, proba=0.5),
+                        RandomTransformer(BlackWhite, lower=0, upper=0, proba=0.4),
+                        RandomTransformer(GaussianNoise, lower=32, upper=256, proba=0.4),
+                        RandomTransformer(Pixelisator, lower=1.0, upper=4.0, proba=0.2),
+                        RandomTransformer(Blur, lower=2.0, upper=20.0, proba=0.2),
+                        ConvertColor(current='RGB', to='HSV'),
+                        ConvertDataType(to=np.float32),
+                        RandomTransformer(Saturation, lower=0.5, upper=2.5, proba=0.5),
+                        RandomTransformer(Hue, lower=-64, upper=64, proba=0.5),
+                        ConvertDataType(to=np.uint8),
+                        ConvertColor(current='HSV', to='RGB'),
+                        ConvertDataType(to=np.float32),
+                        RandomTransformer(Contrast, lower=0.5, upper=2.5, proba=0.5),
+                        ConvertDataType(to=np.uint8),
+                        RandomChannelSwap(prob=0.0)
+                      ]
+    ]
+
+  def load_image(self, image_path):
+    return cv2.imread(image_path)
+
+  def __call__(self, image, labels=None):
+    if isinstance(image, str):
+      image = self.load_image(image)
+
+    idx = np.random.choice(len(self.sequences))
+    for transformer in self.sequences[idx]:
+      image, labels = transformer(image, labels)
+    return image, labels

{sciveo-0.1.35 → sciveo-0.1.38}/sciveo/ml/nlp/embeddings.py

@@ -123,6 +123,8 @@ class TextEmbedding(BaseML):
     self.init()
     predictions = []
     for current_x in X:
-      embedding = self.predict_one(current_x).tolist()
+      embedding = self.predict_one(current_x)
+      if not isinstance(embedding, list):
+        embedding = embedding.tolist()
       predictions.append(embedding)
     return predictions

sciveo-0.1.38/sciveo/ml/video/description.py

@@ -0,0 +1,41 @@
+#
+# 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 cv2
+import gc
+from PIL import Image
+
+import torch
+from transformers import AutoProcessor, AutoModelForCausalLM
+
+from sciveo.tools.common import *
+from sciveo.ml.images.description import ImageToText
+
+
+class VideoToText(ImageToText):
+  def __init__(self, model_id, max_length=64, cache_dir=None, device=None) -> None:
+    super().__init__(model_id, max_length, cache_dir, device)
+
+  def read_video_frame(self, video_path):
+    cap = cv2.VideoCapture(video_path)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    cap.set(cv2.CAP_PROP_POS_FRAMES, total_frames // 2)
+    ret, frame = cap.read()
+    cap.release()
+    return frame
+
+  def predict(self, X):
+    frames = []
+    for x in X:
+      frames.append(self.read_video_frame(x))
+    predictions = super().predict(frames)
+    return predictions

{sciveo-0.1.35 → sciveo-0.1.38}/sciveo/tools/logger.py

@@ -31,7 +31,7 @@ def _sciveo_get_logger(name):
         log_min_level = logging.getLevelName(_sciveo_log_min_level)
         if (isinstance(log_min_level, str) and log_min_level.startswith("Level")):
           log_min_level = "DEBUG"
-        if isinstance(log_min_level, int) and log_min_level < 10:
+        elif isinstance(log_min_level, int) and log_min_level < 10:
           log_min_level = "DEBUG"
         logger.setLevel(log_min_level)
 

sciveo-0.1.38/sciveo/version.py

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

{sciveo-0.1.35 → sciveo-0.1.38}/sciveo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.35
+Version: 0.1.38
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

{sciveo-0.1.35 → sciveo-0.1.38}/sciveo.egg-info/SOURCES.txt

@@ -97,9 +97,11 @@ sciveo/ml/images/description.py
 sciveo/ml/images/embeddings.py
 sciveo/ml/images/object_detection.py
 sciveo/ml/images/tools.py
-sciveo/ml/images/transforms.py
+sciveo/ml/images/transformers.py
 sciveo/ml/nlp/__init__.py
 sciveo/ml/nlp/embeddings.py
+sciveo/ml/video/__init__.py
+sciveo/ml/video/description.py
 sciveo/monitoring/__init__.py
 sciveo/monitoring/monitor.py
 sciveo/monitoring/start.py