Merge pull request #387 from superannotateai/friday-754

Friday 754

Author: dshabin

src/superannotate/__init__.py

@@ -239,4 +239,5 @@ def log_version_info():
             )
 
 
-log_version_info()
+if not os.environ.get("SA_VERSION_CHECK", "True").lower() == "false":
+    log_version_info()

src/superannotate/lib/app/interface/base_interface.py

@@ -12,5 +12,5 @@ def controller(self):
             raise Exception("Config does not exists!")
         controller = Controller()
         if self._config_path:
-            controller.init(self._config_path)
+            controller.init(config_path=self._config_path)
         return controller

src/superannotate/lib/app/interface/sdk_interface.py

@@ -53,17 +53,20 @@
 
 
 @validate_arguments
-def init(path_to_config_json: Optional[str] = None):
+def init(path_to_config_json: Optional[str] = None, token: str = None):
     """
     Initializes and authenticates to SuperAnnotate platform using the config file.
     If not initialized then $HOME/.superannotate/config.json
     will be used.
 
     :param path_to_config_json: Location to config JSON file
     :type path_to_config_json: str or Path
+
+    :param token: Team token
+    :type token: str
     """
     global controller
-    controller.init(path_to_config_json)
+    controller.init(config_path=path_to_config_json, token=token)
 
 
 @validate_arguments

src/superannotate/lib/app/interface/types.py

@@ -12,7 +12,7 @@
 from pydantic import validate_arguments as pydantic_validate_arguments
 from pydantic import ValidationError
 from pydantic.errors import StrRegexError
-from superannotate_schemas.schemas.base import ClassTypeEnum
+
 
 NotEmptyStr = constr(strict=True, min_length=1)
 

src/superannotate/lib/core/__init__.py

@@ -9,6 +9,7 @@
 from superannotate.lib.core.enums import UploadState
 from superannotate.lib.core.enums import UserRole
 
+
 CONFIG_FILE_LOCATION = str(Path.home() / ".superannotate" / "config.json")
 LOG_FILE_LOCATION = str(Path.home() / ".superannotate" / "sa.log")
 BACKEND_URL = "https://api.annotate.online"

src/superannotate/lib/infrastructure/controller.py

@@ -52,7 +52,7 @@ def get_instance(cls):
 
 
 class BaseController(metaclass=SingleInstanceMetaClass):
-    def __init__(self, config_path=constances.CONFIG_FILE_LOCATION, token: str = None):
+    def __init__(self, config_path: str, token: str = None):
         self._team_data = None
         self._token = None
         self._backend_url = None
@@ -69,36 +69,36 @@ def __init__(self, config_path=constances.CONFIG_FILE_LOCATION, token: str = Non
         self._user_id = None
         self._team_name = None
         self._reporter = None
-        self._config_path = expanduser(config_path)
-        self._token, self._backend_url = (
-            os.environ.get("SA_TOKEN"),
-            os.environ.get("SA_URL"),
-        )
+        self._ssl_verify = not os.environ.get("SA_TESTING", False)
+        self._config_path = expanduser(config_path) if config_path else constances.CONFIG_FILE_LOCATION
+
+        self._backend_url = os.environ.get("SA_URL", constances.BACKEND_URL)
+        if not token and not config_path:
+            env_token = os.environ.get("SA_TOKEN")
+            if env_token:
+                self._token = self._validate_token(os.environ.get("SA_TOKEN"))
+        if token:
+            self._token = self._validate_token(token)
 
-        if not self._token and token:
-            if self._validate_token(token):
-                self._token = token
-            else:
-                raise AppException("Invalid token.")
-        if not self._token and config_path:
-            self._token, self._backend_url, ssl_verify = self.retrieve_configs(
-                Path(config_path), raise_exception=False
+        if not self._token:
+            self._token, self._backend_url, self._ssl_verify = self.retrieve_configs(
+                Path(self._config_path), raise_exception=False
             )
 
     def retrieve_configs(
         self, path: Path, raise_exception=True
     ) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-        if not path.is_file():
+        if not path.is_file() or not os.access(path, os.R_OK):
             if raise_exception:
                 raise AppException(
                     f"SuperAnnotate config file {str(path)} not found."
                     f" Please provide correct config file location to sa.init(<path>) or use "
                     f"CLI's superannotate init to generate default location config file."
                 )
         try:
-            config_repo = ConfigRepository(self._config_path)
+            config_repo = ConfigRepository(str(path))
             return (
-                config_repo.get_one("token").value,
+                self._validate_token(config_repo.get_one("token").value),
                 config_repo.get_one("main_endpoint").value,
                 config_repo.get_one("ssl_verify").value,
             )
@@ -110,23 +110,32 @@ def retrieve_configs(
             return None, None, None
 
     def init(
-        self, config_path: str = constances.CONFIG_FILE_LOCATION, token: str = None
+        self, token: str = None, backend_url: str = None, config_path: str = None,
     ):
+        if backend_url:
+            self._backend_url = backend_url
         if token:
             if self._validate_token(token):
                 self._token = token
+                return self
             else:
                 raise AppException("Invalid token.")
-        if not token and config_path:
-            self._config_path = config_path
-            self._token, self._backend_url, ssl_verify = self.retrieve_configs(
-                Path(config_path), raise_exception=True
+        if not config_path:
+            raise AppException(
+                " Please provide correct config file location to sa.init(<path>)."
             )
-            self._ssl_verify = False  # TODO fix if ssl_verify is False else True
+        self._config_path = config_path
+        self._token, self._backend_url, ssl_verify = self.retrieve_configs(
+            Path(config_path), raise_exception=True
+        )
+        self._ssl_verify = ssl_verify
+        return self
 
     @property
     def backend_client(self):
         if not self._backend_client:
+            if not self._token:
+                raise AppException("Team token not provided")
             self._backend_client = SuperannotateBackendService(
                 api_url=self._backend_url,
                 auth_token=self._token,
@@ -164,14 +173,12 @@ def _validate_token(token: str):
             int(token.split("=")[-1])
         except ValueError:
             raise AppException("Invalid token.")
+        return token
 
     def set_token(self, token: str, backend_url: str = constances.BACKEND_URL):
-        self._validate_token(token)
-        self._token = token
+        self._token = self._validate_token(token)
+        self._backend_url = backend_url
         self._backend_client = self.backend_client
-        self._backend_client._api_url = backend_url
-        self._backend_client._auth_token = token
-        self._backend_client.get_session.cache_clear()
 
     @property
     def projects(self):
@@ -254,7 +261,8 @@ def annotation_validators(self) -> AnnotationValidators:
 
 
 class Controller(BaseController):
-    def __init__(self, config_path=constances.CONFIG_FILE_LOCATION):
+
+    def __init__(self, config_path: str = None):
         super().__init__(config_path)
         self._team = None
 

src/superannotate/lib/infrastructure/repositories.py

@@ -45,10 +45,8 @@ def _create_config(self):
         return {}
 
     def _get_config(self) -> Optional[dict]:
-        if not os.path.exists(self.config_path):
-            return
-        with open(self.config_path) as config:
-            return json.load(config)
+        if os.path.exists(self.config_path):
+            return json.load(open(self.config_path))
 
     def get_one(self, uuid: str) -> Optional[ConfigEntity]:
         config = self._get_config()

src/superannotate/lib/infrastructure/services.py

@@ -18,9 +18,9 @@
 from lib.core.service_types import UserLimits
 from lib.core.serviceproviders import SuerannotateServiceProvider
 from lib.infrastructure.helpers import timed_lru_cache
-from pydantic import BaseModel
 from requests.exceptions import HTTPError
 
+
 requests.packages.urllib3.disable_warnings()
 
 

src/superannotate/logger.py

@@ -1,8 +1,14 @@
 import logging.config
+import os
+from logging import Formatter
+from logging.handlers import RotatingFileHandler
 from os.path import expanduser
 
 from superannotate import constances
 
+default_logger = None
+
+log_path = "/Users/vaghinak.basentsyan/private/log.log"
 logging.config.dictConfig(
     {
         "version": 1,
@@ -14,29 +20,35 @@
                 "formatter": "consoleFormatter",
                 "stream": "ext://sys.stdout",
             },
-            "fileHandler": {
-                "class": "logging.handlers.RotatingFileHandler",
-                "level": "DEBUG",
-                "formatter": "fileFormatter",
-                "filename": expanduser(constances.LOG_FILE_LOCATION),
-                "mode": "a",
-                "maxBytes": 5 * 1024 * 1024,
-                "backupCount": 5,
-            },
         },
         "formatters": {
             "consoleFormatter": {
                 "format": "SA-PYTHON-SDK - %(levelname)s - %(message)s",
             },
-            "fileFormatter": {
-                "format": "SA-PYTHON-SDK - %(levelname)s - %(asctime)s - %(message)s"
-            },
         },
-        "loggers": {"sa": {"handlers": ["console", "fileHandler"], "level": "DEBUG"}},
+        "loggers": {"sa": {"handlers": ["console"], "level": "DEBUG"}},
     }
 )
 
 
 def get_default_logger():
-    logger = logging.getLogger("sa")
-    return logger
+    global default_logger
+    if not default_logger:
+        default_logger = logging.getLogger("sa")
+        try:
+            log_file_path = expanduser(constances.LOG_FILE_LOCATION)
+            open(log_file_path, "w").close()
+            if os.access(log_file_path, os.W_OK):
+                file_handler = RotatingFileHandler(
+                    expanduser(constances.LOG_FILE_LOCATION),
+                    maxBytes=5 * 1024 * 1024,
+                    backupCount=5,
+                    mode="a"
+                )
+                formatter = Formatter("SA-PYTHON-SDK - %(levelname)s - %(asctime)s - %(message)s")
+                file_handler.setFormatter(formatter)
+                file_handler.setLevel("DEBUG")
+                default_logger.addHandler(file_handler)
+        except OSError:
+            pass
+    return default_logger

tests/unit/test_controller_init.py

@@ -68,13 +68,12 @@ class SKDInitTest(TestCase):
     VALID_JSON = {
         "token": "a"*28 + "=1234"
     }
-    INVALID_JSON ={
+    INVALID_JSON = {
         "token": "a" * 28 + "=1234asd"
     }
     FILE_NAME = "config.json"
     FILE_NAME_2 = "config.json"
 
-    @pytest.mark.skip(reason="Need to adjust")
     def test_init_flow(self):
         with tempfile.TemporaryDirectory() as temp_dir:
             token_path = f"{temp_dir}/config.json"
@@ -84,7 +83,6 @@ def test_init_flow(self):
                 import src.superannotate as sa
                 sa.init(token_path)
 
-    @pytest.mark.skip(reason="Need to adjust")
     def test_init(self):
         with tempfile.TemporaryDirectory() as temp_dir:
             path = join(temp_dir, self.FILE_NAME)
@@ -93,3 +91,6 @@ def test_init(self):
             import src.superannotate as sa
             sa.init(path)
             self.assertEqual(sa.controller.team_id, 1234)
+
+    def test_(self):
+        import superannotate as sa