Merge branch 'main' of https://github.com/roboflow-ai/roboflow-python into login

Author: Jacobsolawetz

Makefile

@@ -17,6 +17,5 @@ check_code_quality:
 
 publish:
 	python setup.py sdist bdist_wheel
-	twine upload -r testpypi dist/* -u ${PYPI_USERNAME} -p ${PYPI_TEST_PASSWORD} --verbose 
 	twine check dist/*
 	twine upload dist/* -u ${PYPI_USERNAME} -p ${PYPI_PASSWORD} --verbose 

roboflow/__init__.py

@@ -11,7 +11,7 @@
 from roboflow.core.workspace import Workspace
 from roboflow.util.general import write_line
 
-__version__ = "0.2.292"
+__version__ = "1.0.0"
 
 def check_key(api_key, model, notebook, num_retries=0):
     if type(api_key) is not str:

roboflow/core/project.py

@@ -268,6 +268,8 @@ def __image_upload(
         hosted_image=False,
         split="train",
         batch_name=DEFAULT_BATCH_NAME,
+        tag_names=[],
+        **kwargs,
     ):
         """function to upload image to the specific project
         :param image_path: path to image you'd like to upload.
@@ -298,6 +300,11 @@ def __image_upload(
                     batch_name,
                 ]
             )
+            for key, value in kwargs.items():
+                self.image_upload_url += "&" + str(key) + "=" + str(value)
+
+            for tag in tag_names:
+                self.image_upload_url = self.image_upload_url + f"&tag={tag}"
 
             # Convert to PIL Image
             img = cv2.imread(image_path)
@@ -339,34 +346,59 @@ def __image_upload(
 
         return response
 
-    def __annotation_upload(self, annotation_path, image_id):
+    def __annotation_upload(self, annotation_path: str, image_id: str):
         """function to upload annotation to the specific project
         :param annotation_path: path to annotation you'd like to upload
         :param image_id: image id you'd like to upload that has annotations for it.
         """
-        # Get annotation string
-        annotation_string = open(annotation_path, "r").read()
+
+        # stop on empty string
+        if len(annotation_path) == 0:
+            print("Please provide a non-empty string for annotation_path.")
+            return {"result": "Please provide a non-empty string for annotation_path."}
+
+        # check if annotation file exists
+        elif os.path.exists(annotation_path):
+            print("-> found given annotation file")
+            annotation_string = open(annotation_path, "r").read()
+
+        # if not annotation file, check if user wants to upload regular as classification annotation
+        elif self.type == "classification":
+            print(f"-> using {annotation_path} as classname for classification project")
+            annotation_string = annotation_path
+
+        # don't attempt upload otherwise
+        else:
+            print(
+                "File not found or uploading to non-classification type project with invalid string"
+            )
+            return {
+                "result": "File not found or uploading to non-classification type project with invalid string"
+            }
+
         # Set annotation upload url
 
         project_name = self.id.rsplit("/")[1]
 
         self.annotation_upload_url = "".join(
             [
                 API_URL + "/dataset/",
-                project_name,
+                self.__project_name,
                 "/annotate/",
                 image_id,
                 "?api_key=",
                 self.__api_key,
                 "&name=" + os.path.basename(annotation_path),
             ]
         )
+
         # Get annotation response
         annotation_response = requests.post(
             self.annotation_upload_url,
             data=annotation_string,
             headers={"Content-Type": "text/plain"},
         )
+
         # Return annotation response
         return annotation_response
 
@@ -382,20 +414,31 @@ def check_valid_image(self, image_path):
 
     def upload(
         self,
-        image_path=None,
-        annotation_path=None,
-        hosted_image=False,
-        image_id=None,
-        split="train",
-        num_retry_uploads=0,
-        batch_name=DEFAULT_BATCH_NAME,
+        image_path: str = None,
+        annotation_path: str = None,
+        hosted_image: bool = False,
+        image_id: int = None,
+        split: str = "train",
+        num_retry_uploads: int = 0,
+        batch_name: str = DEFAULT_BATCH_NAME,
+        tag_names: list = [],
+        **kwargs,
     ):
-        """upload function
-        :param image_path: path to image you'd like to upload
-        :param annotation_path: if you're upload annotation, path to it
-        :param hosted_image: whether the image is hosted
-        :param image_id: id of the image
-        :param split: split to upload the image to
+
+        """Upload image function based on the RESTful API
+
+        Args:
+            image_path (str) - path to image you'd like to upload
+            annotation_path (str) - if you're upload annotation, path to it
+            hosted_image (bool) - whether the image is hosted
+            image_id (int) - id of the image
+            split (str) - to upload the image to
+            num_retry_uploads (int) - how many times to retry upload on failure
+            batch_name (str) - name of batch to upload to within project
+            tag_names (list[str]) - tags to be applied to an image
+
+        Returns:
+            None - returns nothing
         """
 
         is_hosted = image_path.startswith("http://") or image_path.startswith(
@@ -430,6 +473,8 @@ def upload(
                 split=split,
                 num_retry_uploads=num_retry_uploads,
                 batch_name=batch_name,
+                tag_names=tag_names,
+                **kwargs,
             )
         else:
             images = os.listdir(image_path)
@@ -444,6 +489,8 @@ def upload(
                         split=split,
                         num_retry_uploads=num_retry_uploads,
                         batch_name=batch_name,
+                        tag_names=tag_names,
+                        **kwargs,
                     )
                     print("[ " + path + " ] was uploaded succesfully.")
                 else:
@@ -459,6 +506,8 @@ def single_upload(
         split="train",
         num_retry_uploads=0,
         batch_name=DEFAULT_BATCH_NAME,
+        tag_names=[],
+        **kwargs,
     ):
         success = False
         annotation_success = False
@@ -470,6 +519,8 @@ def single_upload(
                 hosted_image=hosted_image,
                 split=split,
                 batch_name=batch_name,
+                tag_names=tag_names,
+                **kwargs,
             )
             # Get JSON response values
             try:
@@ -509,6 +560,7 @@ def single_upload(
                         image_id=image_id,
                         split=split,
                         num_retry_uploads=num_retry_uploads - 1,
+                        **kwargs,
                     )
                     return
                 else:
@@ -543,7 +595,12 @@ def single_upload(
 
             # Give user warning that annotation failed to upload
             if not annotation_success:
-                warnings.warn("Annotation, " + annotation_path + ", failed to upload!")
+                warnings.warn(
+                    "Annotation, "
+                    + annotation_path
+                    + "failed to upload!\n Upload correct annotation file to image_id: "
+                    + image_id
+                )
         else:
             annotation_success = True
 

roboflow/core/version.py

@@ -29,9 +29,10 @@
 from roboflow.models.object_detection import ObjectDetectionModel
 from roboflow.models.semantic_segmentation import SemanticSegmentationModel
 from roboflow.util.general import write_line
+from roboflow.util.annotations import amend_data_yaml
 from roboflow.util.versions import (
+    get_wrong_dependencies_versions,
     print_warn_for_wrong_dependencies_versions,
-    warn_for_wrong_dependencies_versions,
 )
 
 load_dotenv()
@@ -440,7 +441,7 @@ def deploy(self, model_type: str, model_path: str) -> None:
             model_path (str): File path to model weights to be uploaded
         """
 
-        supported_models = ["yolov8", "yolov5"]
+        supported_models = ["yolov8", "yolov5", "yolov7-seg"]
 
         if model_type not in supported_models:
             raise (
@@ -463,7 +464,7 @@ def deploy(self, model_type: str, model_path: str) -> None:
                 [("ultralytics", "<=", "8.0.20")]
             )
 
-        elif model_type == "yolov5":
+        elif model_type in ["yolov5", "yolov7-seg"]:
             try:
                 import torch
             except ImportError as e:
@@ -510,7 +511,7 @@ def deploy(self, model_type: str, model_path: str) -> None:
                     "ultralytics_version": ultralytics.__version__,
                     "model_type": model_type,
                 }
-        elif model_type == "yolov5":
+        elif model_type in ["yolov5", "yolov7-seg"]:
             # parse from yaml for yolov5
 
             with open(os.path.join(model_path, "opt.yaml"), "r") as stream:
@@ -538,11 +539,19 @@ def deploy(self, model_type: str, model_path: str) -> None:
 
         with zipfile.ZipFile(model_path + "roboflow_deploy.zip", "w") as zipMe:
             for file in lista_files:
-                zipMe.write(
-                    model_path + file,
-                    arcname=file,
-                    compress_type=zipfile.ZIP_DEFLATED,
-                )
+                if os.path.exists(model_path + file):
+                    zipMe.write(
+                        model_path + file,
+                        arcname=file,
+                        compress_type=zipfile.ZIP_DEFLATED,
+                    )
+                else:
+                    if file in ["model_artifacts.json", "state_dict.pt"]:
+                        raise (
+                            ValueError(
+                                f"File {file} not found. Please make sure to provide a valid model path."
+                            )
+                        )
 
         res = requests.get(
             f"{API_URL}/{self.workspace}/{self.project}/{self.version}/uploadModel?api_key={self.__api_key}"
@@ -681,7 +690,7 @@ def __get_format_identifier(self, format):
         friendly_formats = {"yolov5": "yolov5pytorch", "yolov7": "yolov7pytorch"}
         return friendly_formats.get(format, format)
 
-    def __reformat_yaml(self, location, format):
+    def __reformat_yaml(self, location: str, format: str):
         """
         Certain formats seem to require reformatting the downloaded YAML.
         It'd be nice if the API did this, but we're doing it in python for now.
@@ -691,28 +700,30 @@ def __reformat_yaml(self, location, format):
 
         :return None:
         """
-        if format in ["yolov5pytorch", "yolov7pytorch", "yolov8"]:
-            with open(location + "/data.yaml") as file:
-                new_yaml = yaml.safe_load(file)
-            new_yaml["train"] = location + new_yaml["train"].lstrip("..")
-            new_yaml["val"] = location + new_yaml["val"].lstrip("..")
-
-            os.remove(location + "/data.yaml")
-
-            with open(location + "/data.yaml", "w") as outfile:
-                yaml.dump(new_yaml, outfile)
-
-        if format == "mt-yolov6":
-            with open(location + "/data.yaml") as file:
-                new_yaml = yaml.safe_load(file)
-            new_yaml["train"] = location + new_yaml["train"].lstrip(".")
-            new_yaml["val"] = location + new_yaml["val"].lstrip(".")
-            new_yaml["test"] = location + new_yaml["test"].lstrip(".")
-
-            os.remove(location + "/data.yaml")
+        data_path = os.path.join(location, "data.yaml")
+
+        def data_yaml_callback(content: dict) -> dict:
+            if format == "mt-yolov6":
+                content["train"] = location + content["train"].lstrip(".")
+                content["val"] = location + content["val"].lstrip(".")
+                content["test"] = location + content["test"].lstrip(".")
+            if format in ["yolov5pytorch", "yolov7pytorch", "yolov8"]:
+                content["train"] = location + content["train"].lstrip("..")
+                content["val"] = location + content["val"].lstrip("..")
+            try:
+                # get_wrong_dependencies_versions raises exception if ultralytics is not installed at all
+                if format == "yolov8" and not get_wrong_dependencies_versions(
+                    dependencies_versions=[("ultralytics", ">=", "8.0.30")]
+                ):
+                    content["train"] = "train/images"
+                    content["val"] = "valid/images"
+                    content["test"] = "test/images"
+            except ModuleNotFoundError:
+                pass
+            return content
 
-            with open(location + "/data.yaml", "w") as outfile:
-                yaml.dump(new_yaml, outfile)
+        if format in ["yolov5pytorch", "mt-yolov6", "yolov7pytorch", "yolov8"]:
+            amend_data_yaml(path=data_path, callback=data_yaml_callback)
 
     def __str__(self):
         """string representation of version object."""

roboflow/models/classification.py

@@ -59,6 +59,7 @@ def predict(self, image_path, hosted=False):
             # Create buffer
             buffered = io.BytesIO()
             image.save(buffered, quality=90, format="JPEG")
+            img_dims = image.size
             # Base64 encode image
             img_str = base64.b64encode(buffered.getvalue())
             img_str = img_str.decode("ascii")
@@ -81,9 +82,9 @@ def predict(self, image_path, hosted=False):
 
         return PredictionGroup.create_prediction_group(
             resp.json(),
+            image_dims=img_dims,
             image_path=image_path,
             prediction_type=CLASSIFICATION_MODEL,
-            image_dims=image_dims,
             colors=self.colors,
         )
 

roboflow/util/annotations.py

@@ -0,0 +1,13 @@
+import os
+from typing import Callable
+
+import yaml
+
+
+def amend_data_yaml(path: str, callback: Callable[[dict], dict]):
+    with open(path) as source:
+        content = yaml.safe_load(source)
+    content = callback(content)
+    os.remove(path)
+    with open(path, "w") as target:
+        yaml.dump(content, target)

roboflow/util/versions.py

@@ -8,7 +8,7 @@ def get_wrong_dependencies_versions(
     dependencies_versions: List[Tuple[str, str, str]]
 ) -> List[Tuple[str, str, str, str]]:
     """
-    Get a list of missmatching dependencies with current version installed.
+    Get a list of mismatching dependencies with current version installed.
     E.g., assuming we pass `get_wrong_dependencies_versions([("torch", "==", "1.2.0")]), we will check if the current version of `torch` is `==1.2.0`. If not, we will return `[("torch", "==", "1.2.0", "<current_installed_version>")]
 
     We support `<=`, `==`, `>=`