layernext-beta 2.2.1b6__tar.gz → 2.2.1b8__tar.gz

{layernext-beta-2.2.1b6/layernext_beta.egg-info → layernext-beta-2.2.1b8}/PKG-INFO

@@ -1,13 +1,10 @@
 Metadata-Version: 2.1
 Name: layernext-beta
-Version: 2.2.1b6
+Version: 2.2.1b8
 Summary: LayerNext Python SDK
-Home-page: UNKNOWN
 Author: LayerNext
 Author-email: <support@layernext.ai>
-License: UNKNOWN
 Keywords: python,datalake,datasetsync,ai,annotation,layernext,layernext,machine learning
-Platform: UNKNOWN
 Classifier: Development Status :: 1 - Planning
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -40,5 +37,3 @@ url = 'https://api.xxxx.layernext.ai'
 client = layernext.LayerNextClient(api_key, secret, url)
 
 ```
-
-

{layernext-beta-2.2.1b6 → layernext-beta-2.2.1b8}/layernext/__init__.py

@@ -1,12 +1,14 @@
 import base64
+import datetime
+
 from typing import List, Union, Dict
 from layernext import datalake, dataset, studio, automatic_analysis
-from layernext.datalake.constants import (AnnotationUploadType, ItemType,
+from layernext.datalake.constants import (AnnotationUploadType, ItemType, JobStatus, JobType,
                                           MediaType, ObjectType, SortField,
                                           SortFieldName, SortOrder, AnnotationShapeType)
 from deprecated import deprecated
 
-__version__ = '2.2.1b6'
+__version__ = '2.2.1b8'
 
 
 class LayerNextClient:
@@ -423,6 +425,15 @@ class LayerNextClient:
             self.encoded_key_secret, self.layernext_url)
 
         return _datalake_client.get_collection_details(collection_id, fields_filter)
+    
+    """
+    Use to get system image, video, other count 
+    """
+    def get_system_stat_count(self):
+        _datalake_client = datalake.DatalakeClient(
+        self.encoded_key_secret, self.layernext_url)
+
+        return _datalake_client.get_system_stat_count()
 
     """
     get collection id by name
@@ -2030,14 +2041,27 @@ class LayerNextClient:
             self,
             collection_id, 
             model_id='default',
-            input_resolution=(300,300), 
+            input_resolution=(480,480), 
             confidence_threshold=0.5  
             ):
         
+        session_id = str(datetime.datetime.now().timestamp())
+        job_name = f"Auto-tagging-generate-{model_id}"
+        
+        res_obj = self.create_or_update_job(session_id, job_name, JobType.GENERATE_AUTO_TAGGING.value, 0, JobStatus.QUEUED.value)
+
+        if("success" in res_obj and res_obj["success"]==True) and res_obj["jobId"] is not None:
+            job_id = res_obj["jobId"]
+        else:
+            print("Error occurred while create job")
+            raise Exception("Error occurred while create job")
+        
         _automatic_analysis_client = automatic_analysis.AutomaticAnalysisClient(
             self.encoded_key_secret, self.layernext_url)
-        _automatic_analysis_client.model_tag_collection(
-            collection_id, model_id, input_resolution,confidence_threshold)
+        res = _automatic_analysis_client.model_tag_collection(
+            collection_id, model_id, input_resolution,confidence_threshold,session_id,job_id,job_name)
+        
+        return res
 
 
     """
@@ -2055,10 +2079,23 @@ class LayerNextClient:
             confidence_threshold=0.5   
             ):
         
+        session_id = str(datetime.datetime.now().timestamp())
+        job_name = f"Auto-tagging-generate-{model_id}"
+        
+        res_obj = self.create_or_update_job(session_id, job_name, JobType.GENERATE_AUTO_TAGGING.value, 0, JobStatus.QUEUED.value)
+
+        if("success" in res_obj and res_obj["success"]==True) and res_obj["jobId"] is not None:
+            job_id = res_obj["jobId"]
+        else:
+            print("Error occurred while create job")
+            raise Exception("Error occurred while create job")
+        
         _automatic_analysis_client = automatic_analysis.AutomaticAnalysisClient(
             self.encoded_key_secret, self.layernext_url)
-        _automatic_analysis_client.model_tag_population(
-            item_type, model_id, input_resolution, confidence_threshold)
+        res = _automatic_analysis_client.model_tag_population(
+            item_type, model_id, input_resolution, confidence_threshold,session_id,job_id,job_name)
+        
+        return res
 
 
     """
@@ -2068,22 +2105,40 @@ class LayerNextClient:
     @param annotation_type      : bounding box annotation or polygon segment annotation
     @param model_id             : id/name of the model which is registered in the datalake
     @param confidence_threshold : confidence score to consider which objects/segments to consider for the proccedings
+    @auto_annotation_operation  : Operation to do , sam-text, sam-img-encoding
     """
     def auto_annotate_project(
             self,
             project_id, 
-            prompt, 
+            # prompt=[], 
             annotation_type='segment', 
             model_id='default',
-            confidence_threshold=0.5
+            # confidence_threshold=0.5,
+            # auto_annotation_operation='sam-text'
+            **kwargs
             ):
         
         _automatic_analysis_client = automatic_analysis.AutomaticAnalysisClient(
             self.encoded_key_secret, self.layernext_url)
+        # _automatic_analysis_client.model_annotate_collection(
+        #     project_id, model_id, prompt, annotation_type, confidence_threshold, auto_annotation_operation)
         _automatic_analysis_client.model_annotate_collection(
-            project_id, model_id, prompt, annotation_type, confidence_threshold)
-
-
+            project_id, model_id, annotation_type, **kwargs)
+    
+    def prompt_inference(
+            self,
+            name, 
+            shape, 
+            **kwargs
+            ):
+        
+        _automatic_analysis_client = automatic_analysis.AutomaticAnalysisClient(
+            self.encoded_key_secret, self.layernext_url)
+      
+        _automatic_analysis_client.prompt_infer_image(
+            name, 
+            shape, **kwargs)
+        
     """
     generate embedding for a given collection (image) and upload the embeddings to the vector database
     @param collection_id: id of the image.
@@ -2092,15 +2147,55 @@ class LayerNextClient:
     def generate_embeddings_for_collection(
             self, 
             collection_id, 
-            model_id='default'           
+            model_id='default',
+            query="",
+            filters={}        
             ):
         
+        session_id = str(datetime.datetime.now().timestamp())
+        job_name = f"Embedding-generate-{model_id}"
+        
+        res_obj = self.create_or_update_job(session_id, job_name, JobType.GENERATE_EMBEDDING.value, 0, JobStatus.QUEUED.value)
+
+        if("success" in res_obj and res_obj["success"]==True) and res_obj["jobId"] is not None:
+            job_id = res_obj["jobId"]
+        else:
+            print("Error occurred while create job")
+            raise Exception("Error occurred while create job")
+        
         _automatic_analysis_client = automatic_analysis.AutomaticAnalysisClient(
             self.encoded_key_secret, self.layernext_url)
-        _automatic_analysis_client.embedding_model_inference_collection(
-            collection_id, model_id)
+        res = _automatic_analysis_client.embedding_model_inference_collection(
+            collection_id, model_id, query, filters, session_id,job_id, job_name)
+        return res
 
 
+    def generate_embeddings_to_metalake(
+            self, 
+            item_type='image', 
+            model_id='default',
+            query="",
+            filters={}     
+            ):
+        
+        session_id = str(datetime.datetime.now().timestamp())
+        job_name = f"Embedding-generate-{model_id}"
+        
+        res_obj = self.create_or_update_job(session_id, job_name, JobType.GENERATE_EMBEDDING.value, 0, JobStatus.QUEUED.value)
+
+        if("success" in res_obj and res_obj["success"]==True) and res_obj["jobId"] is not None:
+            job_id = res_obj["jobId"]
+        else:
+            print("Error occurred while create job")
+            raise Exception("Error occurred while create job")
+        
+        _automatic_analysis_client = automatic_analysis.AutomaticAnalysisClient(
+            self.encoded_key_secret, self.layernext_url)
+        res = _automatic_analysis_client.model_embedding_population(
+            item_type, model_id, query, filters, session_id,job_id, job_name)
+        
+        return res
+
     """
     get item list from data lake
     @item_type: "image", "video", "other", "image_collection", "video_collection", "other_collection", "dataset"
@@ -2149,6 +2244,44 @@ class LayerNextClient:
             page_size,
             sort_filter
         )
+    
+    """
+    get item count from metalake
+    @item_type: "image", "video", "other", "image_collection", "video_collection", "other_collection", "dataset"
+    @query: metalake query
+    @filter: {date: {fromDate: "", toDate: ""}, "annotation_types": ["human", "raw", "machine"]}
+    """
+    def get_item_count_from_metalake(
+            self,
+            item_type,
+            query: str = "",
+            filter={},
+    ):
+
+        _datalake_client = datalake.DatalakeClient(
+            self.encoded_key_secret, self.layernext_url)
+        item_type_enum = 2
+        if item_type == "image":
+            item_type_enum = ObjectType.IMAGE.value
+        elif item_type == "video":
+            item_type_enum = ObjectType.VIDEO.value
+        elif item_type == "other":
+            item_type_enum = ObjectType.OTHER.value
+        elif item_type == "image_collection":
+            item_type_enum = ObjectType.IMAGE_COLLECTION.value
+        elif item_type == "video_collection":
+            item_type_enum = ObjectType.VIDEO_COLLECTION.value
+        elif item_type == "other_collection":
+            item_type_enum = ObjectType.OTHER_COLLECTION.value
+        elif item_type == "dataset":
+            item_type_enum = ObjectType.DATASET.value
+
+        filter = self.__create_filter(filter)
+        return _datalake_client.get_item_count_from_metalake(
+            item_type_enum,
+            query,
+            filter,
+        )
 
     """
     download files from collection(videos, images, others)
@@ -2343,6 +2476,61 @@ class LayerNextClient:
             page_size,
             sort_filter
         )
+    
+    """
+    get item count from collection in datalake
+    @collection_id: id of the collection
+    @query: datalake query
+    @filter: {date: {fromDate: "", toDate: ""},  "annotation_types": ["human", "raw", "machine"]}
+    """
+    def get_item_count_from_collection(
+            self,
+            collection_id,
+            query: str = "",
+            filter={},
+    ):
+
+        _datalake_client = datalake.DatalakeClient(
+            self.encoded_key_secret, self.layernext_url)
+        item_type_enum = 2
+        if collection_id == None or collection_id == "":
+            return {
+                "isSuccess": False,
+                "error": 'collection id must be provided'
+            }
+
+        object_type_object = self.__get_object_type_by_id(collection_id)
+        object_type = None
+        if "objectType" in object_type_object:
+            object_type = object_type_object["objectType"]
+
+        if object_type == None:
+            print('object type cannot find for collection id')
+            return {
+                "isSuccess": False,
+                "error": 'object type cannot find for collection id'
+            }
+        if object_type == ObjectType.IMAGE_COLLECTION.value:
+            item_type_enum = ObjectType.IMAGE.value
+        elif object_type == ObjectType.VIDEO_COLLECTION.value:
+            item_type_enum = ObjectType.VIDEO.value
+        elif object_type == ObjectType.OTHER_COLLECTION.value:
+            item_type_enum = ObjectType.OTHER.value
+        else:
+            return {
+                "isSuccess": False,
+                "error": 'collection type is not acceptable get item list'
+            }
+
+        filter = self.__create_filter(filter)
+        # filter["contentType"] = item_type_enum
+
+        return _datalake_client.get_item_count_from_collection(
+            item_type_enum,
+            collection_id,
+            query,
+            filter,
+        )
 
     """
     Use for insert embedding list to images
@@ -2360,7 +2548,7 @@ class LayerNextClient:
     embedding vector dimension limit 2048
     """
 
-    def insert_image_embeddings_batch(self, embedding_list: List[Dict[str, List[float]]], model_name: str, vector_dimension: List[int]):
+    def insert_image_embeddings_batch(self, embedding_list: List[Dict[str, List[float]]], model_name: str, vector_dimension: List[int], session_id: str= ""):
         if embedding_list == None:
             return {
                 "success": False,
@@ -2394,7 +2582,7 @@ class LayerNextClient:
         _datalake_client = datalake.DatalakeClient(
             self.encoded_key_secret, self.layernext_url)
 
-        return _datalake_client.insert_embeddings_batch(embedding_list, model_name, vector_dimension)
+        return _datalake_client.insert_embeddings_batch(embedding_list, model_name, vector_dimension, session_id)
 
     """
     Use for insert embedding list to images
@@ -2410,10 +2598,13 @@ class LayerNextClient:
     ]
     uniqueName string length limit 256 characters
     embedding vector dimension limit 2048
-    """
-
+    """        
     def insert_image_embeddings(
             self, embedding_list: List[Dict[str, List[float]]], model_name: str, vector_dimension: List[int]) -> dict:
+        
+        total_count = len(embedding_list)
+        session_uuid = str(datetime.datetime.now().timestamp())
+        job_name = f"Embedding-upload-{model_name}"
         if embedding_list == None:
             return {
                 "success": False,
@@ -2424,19 +2615,40 @@ class LayerNextClient:
                 "success": False,
                 "message": "embedding_list is not a list"
             }
+        
+        self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, 0, JobStatus.QUEUED.value, {"modelName":model_name, "embeddingUploadTotalCount":total_count})
+
         count = 0
+        continues_count = 0
+        object_key_list = []
         temp_embedding_list = []
+        status = JobStatus.IN_PROGRESS.value
         inserted_count = 0
         message_list = []
         for embedding in embedding_list:
             if count == len(embedding_list)-1:
+
                 temp_embedding_list.append(embedding)
+                if('uniqueName' in embedding and isinstance(embedding['uniqueName'], str)):
+                    object_key_list.append(embedding['uniqueName'])
+                else:
+                    self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, 0, JobStatus.FAILED.value, {"errorList": f"Invalid embedding object: {embedding}"})
+                    return {"success":False}
+                
                 response = self.insert_image_embeddings_batch(
                     temp_embedding_list, model_name, vector_dimension)
                 if response["message"] != "":
                     message_list.append(response["message"])
                 if response["success"] == False:
+                    self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, 0, JobStatus.FAILED.value, {"embeddingUploadTryObjectKeys":object_key_list,"errorList":"Error occur while uploading embeddings"})
+                    object_key_list = []
                     return response
+                
+                progress = (continues_count/total_count)*100
+                if (progress == 100):
+                    status = JobStatus.COMPLETED.value
+                self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, progress, status, {"embeddingUploadSuccessObjectKeys":object_key_list, "embeddingUploadSuccessCount": continues_count})
+                object_key_list = []
                 inserted_count += response["upsert_count"]
                 return {
                     "success": True,
@@ -2449,13 +2661,32 @@ class LayerNextClient:
                 if response["message"] != "":
                     message_list.append(response["message"])
                 if response["success"] == False:
+                    self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, 0, JobStatus.FAILED.value, {"embeddingUploadTryObjectKeys":object_key_list,"errorList":"Error occur while uploading embeddings"})
+                    object_key_list = []
                     return response
+                
+                progress = (continues_count/total_count)*100
+                if (progress == 100):
+                    status = JobStatus.COMPLETED.value
+                self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, progress, status, {"embeddingUploadSuccessObjectKeys":object_key_list, "embeddingUploadSuccessCount":continues_count})
+                object_key_list = []
                 inserted_count += response["upsert_count"]
                 temp_embedding_list = []
             else:
                 temp_embedding_list.append(embedding)
+                if('uniqueName' in embedding and isinstance(embedding['uniqueName'], str)):
+                    object_key_list.append(embedding['uniqueName'])
+                else:
+                    self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, 0, JobStatus.FAILED.value, {"errorList": f"Invalid embedding object: {embedding}"})
+                    return {"success":False}
             count += 1
+            continues_count += 1
 
+        progress = (continues_count/total_count)*100
+        if (progress == 100):
+            status = JobStatus.COMPLETED.value
+        self.create_or_update_job(session_uuid, job_name,JobType.UPLOAD_EMBEDDING.value, progress, status, {"embeddingUploadSuccessObjectKeys":object_key_list, "embeddingUploadSuccessCount":continues_count})
+        object_key_list = []
         return {
             "success": True,
             "upsert_count": inserted_count,
@@ -2487,3 +2718,29 @@ class LayerNextClient:
             unique_names,
             model_name
         ) 
+    
+    def create_or_update_job(
+        self, 
+        session_id:str, 
+        job_name:str,
+        job_type:int, 
+        progress:int, 
+        status:int, 
+        job_detail:dict={}
+    ):
+        
+        if(not isinstance(session_id, str) or not isinstance(job_name, str) or not isinstance(progress, (int, float)) or not isinstance(JobStatus(status), JobStatus) or not isinstance(JobType(job_type), JobType)):
+            print("Invalid input field. Please check and retry")
+            raise Exception("Cannot create or update job. Invalid input field. Please check and retry")
+
+        _datalake_client = datalake.DatalakeClient(
+            self.encoded_key_secret, self.layernext_url)
+
+        return _datalake_client.create_or_update_job(
+            session_id, 
+            job_name, 
+            job_type,
+            progress, 
+            status, 
+            job_detail
+        )

{layernext-beta-2.2.1b6 → layernext-beta-2.2.1b8}/layernext/automatic_analysis/__init__.py

@@ -1,5 +1,6 @@
-from .automatic_analysis_interface import AutomaticAnalysisInterface
-from .support import make_tarfile_in_memory
+from layernext.automatic_analysis.automatic_analysis_interface import AutomaticAnalysisInterface
+from .automatic_analysis import AutomaticAnalysis
+from .support import make_tarfile_in_memory, validate_input_prompt, validate_input_annotation_type, validate_confidence, validate_task, validate_resolution_input
 """
 Class to initiate AutomaticAnalysisClient and handle functions integrated to it
 """
@@ -14,6 +15,7 @@ class AutomaticAnalysisClient:
         _automatic_analysis_url = f'{layernext_url}/analytics' 
         self.encoded_key_secret=encoded_key_secret
         self.layernext_url=layernext_url
+        self.automatic_analysis = AutomaticAnalysis(encoded_key_secret, _automatic_analysis_url)
         self.automatic_analysis_interface = AutomaticAnalysisInterface(encoded_key_secret, _automatic_analysis_url)
 
 
@@ -31,10 +33,12 @@ class AutomaticAnalysisClient:
             _datalake_client, 
             task
             ):
-        
-        storage_url,bucket_name, object_key, label_list,model_name=make_tarfile_in_memory(input_model_path, model_id, _datalake_client)
-        self.automatic_analysis_interface.inference_model_upload(storage_url,bucket_name, object_key,model_id,label_list,model_name, task)
-
+        try:
+            validate_task(task)
+            storage_url,bucket_name, object_key, label_list,model_name=make_tarfile_in_memory(input_model_path, model_id, _datalake_client)
+            self.automatic_analysis_interface.inference_model_upload(storage_url,bucket_name, object_key,model_id,label_list,model_name, task)
+        except ValueError as e:
+            print(f"ValueError: {e}")
 
     """
     initiate the API call to the flask app to autotagging a given collection through tagger_detail_send
@@ -48,13 +52,21 @@ class AutomaticAnalysisClient:
             collection_id, 
             model_id, 
             input_resolution, 
-            confidence_threshold
+            confidence_threshold,
+            session_id,
+            job_id,
+            job_name
             ):
-        
-        application='collection_autotag'
-        item_type=""
-        self.automatic_analysis_interface.tagger_detail_send(
-            application, collection_id, item_type, model_id, input_resolution, confidence_threshold)
+        try:
+            validate_confidence(confidence_threshold)
+            validate_resolution_input(input_resolution)
+            application='collection_autotag'
+            item_type=""
+            self.automatic_analysis.tagger_detail_send(
+                application, collection_id, item_type, model_id, input_resolution, confidence_threshold,session_id,job_id,job_name)
+        except ValueError as e:
+            print(f"ValueError: {e}")
+
     """
     initiate the API call to the flask app to autotagging a given item type files through tagger_detail_send
     @param item_type            : "image", "video", "other", "image_collection", "video_collection", "other_collection", "dataset"
@@ -67,13 +79,20 @@ class AutomaticAnalysisClient:
             item_type,
             model_id,
             input_resolution, 
-            confidence_threshold
+            confidence_threshold,
+            session_id,
+            job_id,
+            job_name
             ):
-        
-        application='population_autotag'
-        collection_id=""
-        self.automatic_analysis_interface.tagger_detail_send(
-            application,collection_id,item_type,model_id,input_resolution, confidence_threshold)
+        try:
+            application='population_autotag'
+            collection_id=""
+            validate_confidence(confidence_threshold)
+            validate_resolution_input(input_resolution)
+            self.automatic_analysis.tagger_detail_send(
+                application,collection_id,item_type,model_id,input_resolution, confidence_threshold,session_id,job_id,job_name)
+        except ValueError as e:
+            print(f"ValueError: {e}")
 
     """
     auto annotating a given frames of an annotation project
@@ -82,20 +101,47 @@ class AutomaticAnalysisClient:
     @param annotation_type      : bounding box annotation or polygon segment annotation
     @param model_id             : id/name of the model which is registered in the datalake
     @param confidence_threshold : confidence score to consider which objects/segments to consider for the proccedings
+    @auto_annotation_operation  : Operation to do , sam-text, sam-img-encoding
     """
     def model_annotate_collection(
             self, 
             project_id, 
             model_id, 
-            prompt, 
+            # prompt, 
             annotation_type, 
-            confidence_threshold
+            # confidence_threshold,
+            # auto_annotation_operation
+            **kwargs
             ):
         
         application='collection_autoannotate'
-        self.automatic_analysis_interface.annotater_detail_send(
-            application,project_id,model_id, prompt, annotation_type, confidence_threshold)
+        
  
+        try:
+            validate_input_annotation_type(annotation_type)
+            if "prompt" in kwargs:
+                validate_input_prompt(kwargs["prompt"])
+            if "confidence_threshold" in kwargs:
+                validate_confidence(kwargs["confidence_threshold"])
+            self.automatic_analysis.annotater_detail_send(
+                application,project_id,model_id, annotation_type, **kwargs)
+        except ValueError as e:
+            print(f"ValueError: {e}")
+    
+    def prompt_infer_image(
+            self, 
+            name, 
+            shape, 
+            **kwargs
+            ):
+        
+        try:
+            self.automatic_analysis_interface.prompt_detail_send(
+                name, 
+                shape, **kwargs)
+        except ValueError as e:
+            print(f"ValueError: {e}")
+
     """
     generate embedding for a given collection (image) and upload the embeddings to the vector database
     @param collection_id: id of the image.
@@ -104,8 +150,32 @@ class AutomaticAnalysisClient:
     def embedding_model_inference_collection(
             self,
             collection_id,
-            model_id):
+            model_id, 
+            query, 
+            filters,
+            session_id,
+            job_id,
+            job_name):
         
         application ='collection_embedding'
-        self.automatic_analysis_interface.embedding_detail_send(
-            collection_id, model_id, application)
+        item_type=""
+        return self.automatic_analysis.embedding_detail_send(
+            collection_id, model_id, application,item_type, query, filters, session_id,job_id,job_name)
+
+    def model_embedding_population(
+            self,
+            item_type,
+            model_id, 
+            query, 
+            filters,
+            session_id,
+            job_id,
+            job_name
+            ):
+        try:
+            application='population_embedding'
+            collection_id=""
+            return self.automatic_analysis.embedding_detail_send(
+                collection_id, model_id, application,item_type, query, filters, session_id, job_id, job_name)
+        except ValueError as e:
+            print(f"ValueError: {e}")