sciveo 0.1.34__tar.gz → 0.1.36__tar.gz

{sciveo-0.1.34 → sciveo-0.1.36}/PKG-INFO

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

{sciveo-0.1.34 → sciveo-0.1.36}/sciveo/cli.py

@@ -21,7 +21,13 @@ def main():
   config = GlobalConfiguration.get()
 
   parser = argparse.ArgumentParser(description='sciveo CLI')
-  parser.add_argument('command', choices=['init', 'monitor', 'scan', 'media-server', 'media-run'], help='Command to execute')
+  parser.add_argument(
+    'command',
+    choices=[
+      'init', 'monitor', 'scan',
+      'media-server', 'media-run'
+    ],
+    help='Command to execute')
 
   parser.add_argument('--period', type=int, default=120, help='Period in seconds')
   parser.add_argument('--block', type=bool, default=True, help='Block flag')
@@ -36,6 +42,8 @@ def main():
   parser.add_argument('--height', type=str, default=None, help='height')
   parser.add_argument('--rate', type=int, help='Rate number')
   parser.add_argument('--processor', type=str, help='Processor name')
+  parser.add_argument('--src', type=str, default=None, help='Source')
+  parser.add_argument('--dst', type=str, default=None, help='Destination')
 
   args = parser.parse_args()
 

{sciveo-0.1.34 → sciveo-0.1.36}/sciveo/media/pipelines/pipeline.py

@@ -70,7 +70,7 @@ class MediaPipeline:
       "video-frames-extract": VideoFramesExtract,
       "video-motion-detector": VideoMotionDetector,
       "video-album": VideoAlbum,
-      "video-to-text": VideoToText,
+      "video-to-text": VideoToTextProcessor,
 
       "image-resize": ImageResize,
       "image-histogram": ImageHistogram,
@@ -80,11 +80,11 @@ class MediaPipeline:
       "image-watermark": ImageWatermark,
       "image-diffusion": ImageDiffusionText,
       "image-diffusion-image-text": ImageDiffusionImageText,
-      "image-to-text": ImageToText,
+      "image-to-text": ImageToTextProcessor,
       "image-fgbg-filter": ImageFGBGFilter,
       "image-segmentation": ImageSegmentation,
       "image-depth-estimation": ImageDepthEstimation,
-      "image-embedding": ImageEmbedding,
+      "image-embedding": ImageEmbeddingProcessor,
       "image-object-detection": ImageObjectDetectionProcessor,
 
       "sci-timeseries-predictor": TimeSeriesPredictorProcessor,

sciveo-0.1.36/sciveo/media/pipelines/processors/image/embeddings.py

@@ -0,0 +1,49 @@
+#
+# 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 boto3
+import cv2
+from PIL import Image
+
+import torch
+from torchvision import models, transforms
+
+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.embeddings import ImageEmbedding
+
+
+class ImageEmbeddingProcessor(TPUBaseProcessor):
+  def __init__(self, processor_config, max_progress) -> None:
+    super().__init__(processor_config, max_progress)
+
+    self.default.update({
+      "model_id": 1,
+      "output": False
+    })
+
+    self.predictor = ImageEmbedding(self['model_id'])
+    self.api = ApiContent()
+
+  def process(self, media):
+    debug("process", media['guid'])
+    embedding = self.predictor.predict_one(media)
+    self.api.update(media, {"embedding_resnet_512": list(embedding)})
+    return media
+
+  def content_type(self):
+    return "image"
+
+  def name(self):
+    return "image-embedding"

{sciveo-0.1.34 → sciveo-0.1.36}/sciveo/media/pipelines/processors/image/generators.py

@@ -24,6 +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
 
 
 class ImageDiffusionText(TPUBaseProcessor):
@@ -150,14 +151,13 @@ class ImageDiffusionText(TPUBaseProcessor):
     return False
 
 
-class ImageToText(TPUBaseProcessor):
+class ImageToTextProcessor(TPUBaseProcessor):
   def __init__(self, processor_config, max_progress) -> None:
     super().__init__(processor_config, max_progress)
 
     self.api = ApiContent()
 
-    cache_dir = os.path.join(os.environ['MEDIA_MODELS_BASE_PATH'], "models/")
-
+    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({
@@ -166,44 +166,16 @@ class ImageToText(TPUBaseProcessor):
       "output": False
     })
 
-    self.models = [
-      ["GIT", "softel/git-base-v1.0", "auto"],
-      ["GIT", "softel/git-large-v1.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[self['model_id']]
-    self.dtype = model_config[2]
-
-    if model_config[0] == "GIT":
-      self.pipe = AutoProcessor.from_pretrained(model_config[1], cache_dir=cache_dir)
-      self.model = AutoModelForCausalLM.from_pretrained(model_config[1], torch_dtype=self.dtype, cache_dir=cache_dir).to(self.device)
-    elif model_config[0] == "BLIP2":
-      self.pipe = Blip2Processor.from_pretrained(model_config[1], cache_dir=cache_dir)
-      self.model = Blip2ForConditionalGeneration.from_pretrained(model_config[1], torch_dtype=self.dtype, device_map="auto", cache_dir=cache_dir)
-
-    debug("model name", model_config[1], "on device", self.device, "dtype", self.dtype, self.model.dtype)
-    self.dtype = self.model.dtype
+    self.predictor = None
 
   def process(self, media):
     debug("process", media['guid'])
+    if self.predictor is None:
+      self.predictor = ImageToText(self['model_id'], self['max_length'], self.cache_dir, self.device)
     local_path = media["local_path"]
-    frame = cv2.cvtColor(cv2.imread(local_path), cv2.COLOR_BGR2RGB)
-    predict = self.predict_image_text(frame)
+    predict = self.predictor.predict_one(local_path)
     return self.set_media(media, predict)
 
-  def predict_image_text(self, frame):
-    pixel_values = self.pipe(images=frame, return_tensors="pt").pixel_values.to(self.device, self.dtype)
-    ids = self.model.generate(pixel_values=pixel_values, max_length=self["max_length"])
-    predict = self.pipe.batch_decode(ids, skip_special_tokens=True)[0]
-
-    del ids
-    del pixel_values
-
-    debug("process predict", predict)
-    return predict
-
   def set_media(self, media, predict):
     media.setdefault("next", [])
     media["next"].append({

{sciveo-0.1.34 → sciveo-0.1.36}/sciveo/media/pipelines/processors/video/generators.py

@@ -19,28 +19,21 @@ from transformers import AutoProcessor, AutoModelForCausalLM
 
 from sciveo.tools.common import *
 from sciveo.media.pipelines.processors.tpu_base import *
-from sciveo.media.pipelines.processors.image.generators import ImageToText
+from sciveo.media.pipelines.processors.image.generators import ImageToTextProcessor
 from sciveo.media.pipelines.base import ApiContent
+from sciveo.ml.video.description import VideoToText
 
 
-class VideoToText(ImageToText):
+class VideoToTextProcessor(ImageToTextProcessor):
   def __init__(self, processor_config, max_progress) -> None:
     super().__init__(processor_config, max_progress)
 
   def process(self, media):
     debug("process", media['guid'])
-    local_path = media["local_path"]
-
-    cap = cv2.VideoCapture(local_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()
-    if ret:
-      predict = self.predict_image_text(frame)
-      return self.set_media(media, predict)
-    else:
-      return media
+    if self.predictor is None:
+      self.predictor = VideoToText(self['model_id'], self['max_length'], self.cache_dir, self.device)
+    prediction = self.predictor.predict_one(media["local_path"])
+    return self.set_media(media, prediction)
 
   def content_type(self):
     return "video"

sciveo-0.1.36/sciveo/ml/base.py

@@ -0,0 +1,55 @@
+#
+# 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.
+#
+# 2023
+#
+
+from sciveo.tools.logger import *
+from sciveo.tools.configuration import GlobalConfiguration
+
+
+class BaseML:
+  def __init__(self, model_name="base", cache_dir=None, device=None) -> None:
+    self.model_name = model_name
+    self.config = GlobalConfiguration.get()
+
+    if cache_dir is None:
+      self.cache_dir = self.config['MODELS_BASE_PATH']
+    else:
+      self.cache_dir = cache_dir
+
+    if device is None:
+      self.device = os.environ.get("MEDIA_PROCESSING_BACKEND", "cpu")
+    else:
+      self.device = device
+
+    self.init_models()
+
+  def init_models(self):
+    warning("init_models not implemented")
+
+  def init(self):
+    warning("init not implemented")
+
+  def post_init(self):
+    warning("post_init not implemented")
+
+  def predict_one(self, x):
+    warning("predict_one not implemented")
+
+  def predict(self, X):
+    predictions = []
+    for x in X:
+      predictions.append(self.predict_one(x))
+    return predictions
+
+  def train(self, X, Y_true=None):
+    warning("train not implemented")
+
+  def describe(self):
+    return f"{type(self).__name__}: {self.model_name}"

sciveo-0.1.36/sciveo/ml/images/base.py

@@ -0,0 +1,48 @@
+#
+# 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.
+#
+# 2023
+#
+
+import io
+import base64
+import numpy as np
+from PIL import Image
+
+from sciveo.tools.logger import *
+from sciveo.tools.configuration import GlobalConfiguration
+from sciveo.ml.base import BaseML
+
+
+class BaseImageML(BaseML):
+  def __init__(self, model_name=1, cache_dir=None, device=None) -> None:
+    super().__init__(model_name, cache_dir, device)
+
+  def load_image(self, x):
+    if isinstance(x, Image.Image) or isinstance(x, np.ndarray):
+      image = x
+    elif isinstance(x, dict):
+      image = Image.open(x["local_path"])
+    elif isinstance(x, str):
+      if x.startswith("data:image"): # Base64 encoded?
+        image = Image.open(io.BytesIO(base64.b64decode(image)))
+      else:
+        image = Image.open(x)
+    else:
+      warning("unknown image format")
+      image = x
+    return image
+
+  def load(self, X):
+    images = []
+    for x in X:
+      images.append(self.load_image(x))
+    return images
+
+  def predict_one(self, x):
+    return self.predict([x])[0]

sciveo-0.1.36/sciveo/ml/images/description.py

@@ -0,0 +1,64 @@
+#
+# 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 diffusers import StableDiffusionPipeline, LMSDiscreteScheduler
+from diffusers import StableDiffusionInstructPix2PixPipeline, EulerAncestralDiscreteScheduler
+from transformers import AutoProcessor, AutoModelForCausalLM
+from transformers import Blip2Processor, Blip2ForConditionalGeneration
+
+from sciveo.tools.logger import *
+from sciveo.tools.common import *
+from sciveo.ml.images.base import BaseImageML
+
+
+class ImageToText(BaseImageML):
+  def __init__(self, model_id, max_length=64, cache_dir=None, device=None) -> None:
+    super().__init__(model_id, cache_dir, device)
+    self.max_length = max_length
+
+    self.models = [
+      ["GIT", "softel/git-base-v1.0", "auto"],
+      ["GIT", "softel/git-large-v1.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]
+
+    if model_config[0] == "GIT":
+      self.pipe = AutoProcessor.from_pretrained(model_config[1], cache_dir=self.cache_dir)
+      self.model = AutoModelForCausalLM.from_pretrained(model_config[1], torch_dtype=self.dtype, cache_dir=self.cache_dir).to(self.device)
+    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)
+
+    debug("model name", model_config[1], "on device", self.device, "dtype", self.dtype, self.model.dtype)
+    self.dtype = self.model.dtype
+
+  def predict(self, images):
+    images = self.load(images)
+
+    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
+
+    # debug("image description", prediction)
+    return prediction

sciveo-0.1.36/sciveo/ml/images/embeddings.py

@@ -0,0 +1,100 @@
+#
+# 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 boto3
+import cv2
+import io
+import base64
+from PIL import Image
+
+import torch
+from torchvision import models, transforms
+
+import numpy as np
+import pandas as pd
+
+from transformers import AutoTokenizer, AutoModel
+
+from sciveo.tools.logger import *
+from sciveo.ml.images.base import BaseImageML
+
+
+class ImageEmbedding(BaseImageML):
+  def __init__(self, model_id=1, cache_dir=None, device=None) -> None:
+    super().__init__(model_id, cache_dir=cache_dir, device=device)
+
+  def init_models(self):
+    self.model_name = [
+      "softel-resnet18-embedding.pth",
+      "softel-resnet34-embedding.pth",
+      "softel-resnet50-embedding.pth",
+      "softel-resnet101-embedding.pth",
+      "softel-resnet152-embedding.pth",
+    ][int(self.model_name)]
+    self.model_path = os.path.join(self.cache_dir, self.model_name)
+    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.preprocessor = transforms.Compose([
+      transforms.Lambda(lambda img: img.convert("RGB") if img.mode != "RGB" else img),
+      transforms.Resize(256),
+      transforms.CenterCrop(224),
+      transforms.ToTensor(),
+      transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+
+    self.model = None
+
+  def load_model(self):
+    debug("loading model", self.model_name, self.model_path)
+    self.model = torch.load(self.model_path).to(self.device)
+    self.model.eval()
+
+  def init(self):
+    if self.model is None:
+      self.load_model()
+      self.post_init()
+
+  def embed(self, image):
+    image_tensor = self.preprocessor(image).unsqueeze(0).to(self.device)
+    with torch.no_grad():
+      embedding = self.model(image_tensor).to("cpu")
+    return embedding.squeeze().numpy()
+
+  def read_image(self, x):
+    if isinstance(x, dict):
+      if "local_path" in x:
+        return Image.open(x["local_path"])
+      elif "guid" in x:
+        debug("not implemented guid", x["guid"])
+      else:
+        debug("not implemented", x)
+    else:
+      return Image.open(io.BytesIO(base64.b64decode(x)))
+
+  # TODO: should conform to the BaseImageML.predict_one() on image input
+  def predict_one(self, x):
+    self.init()
+    image = self.read_image(x)
+    return self.embed(image)
+
+  def predict(self, X):
+    self.init()
+    predictions = []
+    for current_x in X:
+      embedding = self.predict_one(current_x).tolist()
+      predictions.append(embedding)
+    return predictions

sciveo-0.1.36/sciveo/ml/nlp/embeddings.py

@@ -0,0 +1,128 @@
+#
+# 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 boto3
+import cv2
+import io
+import base64
+from PIL import Image
+
+import torch
+from torchvision import models, transforms
+
+import numpy as np
+import pandas as pd
+
+from transformers import AutoTokenizer, AutoModel
+
+from sciveo.tools.logger import *
+from sciveo.ml.base import BaseML
+
+
+class TextEmbedding(BaseML):
+  def __init__(self, model_name='softel/sentence-base-v0.3', cache_dir=None, device=None) -> None:
+    super().__init__(model_name=model_name, cache_dir=cache_dir, device=device)
+    self.pipe = None
+    self.tokenizer = None
+    self.max_tokens = 512
+    self.overlap = 128
+    self.hidden = False
+
+  def load_model(self):
+    debug("loading model", self.model_name)
+    self.pipe = AutoModel.from_pretrained(
+        self.model_name,
+        cache_dir=self.cache_dir
+    )#.to(self.device)
+    self.tokenizer = AutoTokenizer.from_pretrained(
+      self.model_name,
+      cache_dir=self.cache_dir
+    )
+
+  def init(self):
+    if self.pipe is None or self.tokenizer is None:
+      self.load_model()
+      self.post_init()
+
+  def get_tokens_count(self, text):
+    return len(self.tokenizer(text, padding=False, truncation=False, return_tensors=None)['input_ids'])
+
+  def chunk_text(self, text):
+    tokens = self.tokenizer(text, padding=False, truncation=False, return_tensors=None)['input_ids']
+    chunks = []
+    for i in range(0, len(tokens), self.max_tokens - self.overlap):
+      chunk = tokens[i:i + self.max_tokens]
+      chunks.append(self.tokenizer.decode(chunk, skip_special_tokens=True))
+      if len(chunk) < self.max_tokens:
+        break
+    return chunks
+
+  def get_chuncked_embeddings(self, text):
+    chunks = self.chunk_text(text)
+    embeddings = []
+    for chunk in chunks:
+      embedding = np.array(self.get_sentence_embedding(chunk))
+      embeddings.append(embedding)
+    return np.mean(np.array(embeddings), axis=0)
+
+  def get_sentence_embedding(self, text):
+    while(True):
+      try:
+        return self.embed(text)
+      except:
+        text = text[:len(text) - 8]
+
+  def get_embedding(self, text):
+    total_tokens = self.get_tokens_count(text)
+    if total_tokens<=self.max_tokens:
+      return self.get_sentence_embedding(text).tolist()
+    else:
+      return self.get_chuncked_embeddings(text).tolist()
+
+  def get_chunks_embedding(self, chunks):
+    embeddings = []
+    for text in chunks:
+      embeddings.append(self.get_embedding(text))
+    embeddings = np.array(embeddings)
+    return np.mean(embeddings, axis=0).tolist()
+
+  def embed(self, text):
+    inputs = self.tokenizer.encode_plus(text, return_tensors='pt')#.to(self.device)
+
+    if self.hidden:
+      with torch.no_grad():
+        last_hidden_state = self.pipe(**inputs, output_hidden_states=True).hidden_states[-1]
+        weights_for_non_padding = inputs['attention_mask'] * torch.arange(start=1, end=last_hidden_state.shape[1] + 1).unsqueeze(0)
+        sum_embeddings = torch.sum(last_hidden_state * weights_for_non_padding.unsqueeze(-1), dim=1)
+        num_of_none_padding_tokens = torch.sum(weights_for_non_padding, dim=-1).unsqueeze(-1)
+        embeddings = sum_embeddings / num_of_none_padding_tokens
+    else:
+      outputs = self.pipe(**inputs)
+      sequence_output = outputs[0]
+      input_mask_expanded = inputs['attention_mask'].unsqueeze(-1).expand(sequence_output.size()).float()
+      embeddings = torch.sum(sequence_output * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+    return embeddings.detach().numpy()[0]
+
+  def predict_one(self, x):
+    self.init()
+    if isinstance(x, list):
+      return self.get_chunks_embedding(x)
+    else:
+      return self.get_embedding(x)
+
+  def predict(self, X):
+    self.init()
+    predictions = []
+    for current_x in X:
+      embedding = self.predict_one(current_x).tolist()
+      predictions.append(embedding)
+    return predictions

sciveo-0.1.36/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.34 → sciveo-0.1.36}/sciveo/network/tools.py

@@ -76,7 +76,7 @@ class NetworkTools:
     if self.arguments["localhost"]:
       self.scan_port_hosts(["127.0.0.1"], port)
     self.data["scan"][port].sort(key=lambda ip: int(ip.split('.')[-1]))
-    debug(f"scan_port [{port}] elapsed time {t.stop():.1f}s", self.data["scan"][port])
+    info(f"scan_port [{port}] elapsed time {t.stop():.1f}s", self.data["scan"][port])
     return self.data["scan"][port]
 
   def scan_port_hosts(self, list_ip, port=22):

{sciveo-0.1.34 → sciveo-0.1.36}/sciveo/tools/logger.py

@@ -29,7 +29,9 @@ def _sciveo_get_logger(name):
     with _sciveo_log_lock:
       if not logger.hasHandlers():
         log_min_level = logging.getLevelName(_sciveo_log_min_level)
-        if (isinstance(log_min_level, str) and log_min_level.startswith("Level")) or isinstance(log_min_level, int):
+        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:
           log_min_level = "DEBUG"
         logger.setLevel(log_min_level)
 

sciveo-0.1.36/sciveo/version.py

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