diff --git a/igniter/install_thread.py b/igniter/install_thread.py
index 0cccf664e7..7b8f9c2fca 100644
--- a/igniter/install_thread.py
+++ b/igniter/install_thread.py
@@ -33,7 +33,6 @@ class InstallThread(QThread):
 
     def __init__(self, parent=None,):
         self._mongo = None
-        self._path = None
         self._result = None
 
         QThread.__init__(self, parent)
@@ -62,143 +61,119 @@ class InstallThread(QThread):
             progress_callback=self.set_progress, message=self.message)
         local_version = OpenPypeVersion.get_installed_version_str()
 
-        # if user did enter nothing, we install OpenPype from local version.
-        # zip content of `repos`, copy it to user data dir and append
-        # version to it.
-        if not self._path:
-            # user did not entered url
-            if not self._mongo:
-                # it not set in environment
-                if not os.getenv("OPENPYPE_MONGO"):
-                    # try to get it from settings registry
-                    try:
-                        self._mongo = bs.secure_registry.get_item(
-                            "openPypeMongo")
-                    except ValueError:
-                        self.message.emit(
-                            "!!! We need MongoDB URL to proceed.", True)
-                        self._set_result(-1)
-                        return
-                else:
-                    self._mongo = os.getenv("OPENPYPE_MONGO")
-            else:
-                self.message.emit("Saving mongo connection string ...", False)
-                bs.secure_registry.set_item("openPypeMongo", self._mongo)
-
-            os.environ["OPENPYPE_MONGO"] = self._mongo
-
-            self.message.emit(
-                f"Detecting installed OpenPype versions in {bs.data_dir}",
-                False)
-            detected = bs.find_openpype(include_zips=True)
-
-            if detected:
-                if not OpenPypeVersion.get_installed_version().is_compatible(
-                        detected[-1]):
-                    self.message.emit((
-                        f"Latest detected version {detected[-1]} "
-                        "is not compatible with the currently running "
-                        f"{local_version}"
-                    ), True)
-                    self.message.emit((
-                        "Filtering detected versions to compatible ones..."
-                    ), False)
-
-                    detected = [
-                        version for version in detected
-                        if version.is_compatible(
-                            OpenPypeVersion.get_installed_version())
-                    ]
-
-                if OpenPypeVersion(
-                        version=local_version, path=Path()) < detected[-1]:
-                    self.message.emit((
-                        f"Latest installed version {detected[-1]} is newer "
-                        f"then currently running {local_version}"
-                    ), False)
-                    self.message.emit("Skipping OpenPype install ...", False)
-                    if detected[-1].path.suffix.lower() == ".zip":
-                        bs.extract_openpype(detected[-1])
-                    self._set_result(0)
-                    return
-
-                if OpenPypeVersion(version=local_version).get_main_version() == detected[-1].get_main_version():  # noqa
-                    self.message.emit((
-                        f"Latest installed version is the same as "
-                        f"currently running {local_version}"
-                    ), False)
-                    self.message.emit("Skipping OpenPype install ...", False)
-                    self._set_result(0)
-                    return
-
-                self.message.emit((
-                    "All installed versions are older then "
-                    f"currently running one {local_version}"
-                ), False)
-            else:
-                if getattr(sys, 'frozen', False):
-                    self.message.emit("None detected.", True)
-                    self.message.emit(("We will use OpenPype coming with "
-                                       "installer."), False)
-                    openpype_version = bs.create_version_from_frozen_code()
-                    if not openpype_version:
-                        self.message.emit(
-                            f"!!! Install failed - {openpype_version}", True)
-                        self._set_result(-1)
-                        return
-                    self.message.emit(f"Using: {openpype_version}", False)
-                    bs.install_version(openpype_version)
-                    self.message.emit(f"Installed as {openpype_version}", False)
-                    self.progress.emit(100)
-                    self._set_result(1)
-                    return
-                else:
-                    self.message.emit("None detected.", False)
-
-            self.message.emit(
-                f"We will use local OpenPype version {local_version}", False)
-
-            local_openpype = bs.create_version_from_live_code()
-            if not local_openpype:
-                self.message.emit(
-                    f"!!! Install failed - {local_openpype}", True)
-                self._set_result(-1)
-                return
+        # user did not entered url
+        if self._mongo:
+            self.message.emit("Saving mongo connection string ...", False)
+            bs.secure_registry.set_item("openPypeMongo", self._mongo)
 
+        elif os.getenv("OPENPYPE_MONGO"):
+            self._mongo = os.getenv("OPENPYPE_MONGO")
+        else:
+            # try to get it from settings registry
             try:
-                bs.install_version(local_openpype)
-            except (OpenPypeVersionExists,
-                    OpenPypeVersionInvalid,
-                    OpenPypeVersionIOError) as e:
-                self.message.emit(f"Installed failed: ", True)
-                self.message.emit(str(e), True)
+                self._mongo = bs.secure_registry.get_item(
+                    "openPypeMongo")
+            except ValueError:
+                self.message.emit(
+                    "!!! We need MongoDB URL to proceed.", True)
                 self._set_result(-1)
                 return
+        os.environ["OPENPYPE_MONGO"] = self._mongo
 
-            self.message.emit(f"Installed as {local_openpype}", False)
+        self.message.emit(
+            f"Detecting installed OpenPype versions in {bs.data_dir}",
+            False)
+        detected = bs.find_openpype(include_zips=True)
+        if not detected and getattr(sys, 'frozen', False):
+            self.message.emit("None detected.", True)
+            self.message.emit(("We will use OpenPype coming with "
+                               "installer."), False)
+            openpype_version = bs.create_version_from_frozen_code()
+            if not openpype_version:
+                self.message.emit(
+                    f"!!! Install failed - {openpype_version}", True)
+                self._set_result(-1)
+                return
+            self.message.emit(f"Using: {openpype_version}", False)
+            bs.install_version(openpype_version)
+            self.message.emit(f"Installed as {openpype_version}", False)
             self.progress.emit(100)
             self._set_result(1)
             return
-        else:
-            # if we have mongo connection string, validate it, set it to
-            # user settings and get OPENPYPE_PATH from there.
-            if self._mongo:
-                if not validate_mongo_connection(self._mongo):
-                    self.message.emit(
-                        f"!!! invalid mongo url {self._mongo}", True)
-                    self._set_result(-1)
-                    return
-                bs.secure_registry.set_item("openPypeMongo", self._mongo)
-                os.environ["OPENPYPE_MONGO"] = self._mongo
 
-            self.message.emit(f"processing {self._path}", True)
-            repo_file = bs.process_entered_location(self._path)
+        if detected and not OpenPypeVersion.get_installed_version().is_compatible(
+                detected[-1]):
+            self.message.emit((
+                f"Latest detected version {detected[-1]} "
+                "is not compatible with the currently running "
+                f"{local_version}"
+            ), True)
+            self.message.emit((
+                "Filtering detected versions to compatible ones..."
+            ), False)
 
-            if not repo_file:
-                self.message.emit("!!! Cannot install", True)
-                self._set_result(-1)
+        # filter results to get only compatible versions
+        detected = [
+            version for version in detected
+            if version.is_compatible(
+                OpenPypeVersion.get_installed_version())
+        ]
+
+        if detected:
+            if OpenPypeVersion(
+                    version=local_version, path=Path()) < detected[-1]:
+                self.message.emit((
+                    f"Latest installed version {detected[-1]} is newer "
+                    f"then currently running {local_version}"
+                ), False)
+                self.message.emit("Skipping OpenPype install ...", False)
+                if detected[-1].path.suffix.lower() == ".zip":
+                    bs.extract_openpype(detected[-1])
+                self._set_result(0)
                 return
 
+            if OpenPypeVersion(version=local_version).get_main_version() == detected[
+                -1].get_main_version():  # noqa
+                self.message.emit((
+                    f"Latest installed version is the same as "
+                    f"currently running {local_version}"
+                ), False)
+                self.message.emit("Skipping OpenPype install ...", False)
+                self._set_result(0)
+                return
+
+        self.message.emit((
+            "All installed versions are older then "
+            f"currently running one {local_version}"
+        ), False)
+
+        self.message.emit("None detected.", False)
+
+        self.message.emit(
+            f"We will use local OpenPype version {local_version}", False)
+
+        local_openpype = bs.create_version_from_live_code()
+        if not local_openpype:
+            self.message.emit(
+                f"!!! Install failed - {local_openpype}", True)
+            self._set_result(-1)
+            return
+
+        try:
+            bs.install_version(local_openpype)
+        except (OpenPypeVersionExists,
+                OpenPypeVersionInvalid,
+                OpenPypeVersionIOError) as e:
+            self.message.emit(f"Installed failed: ", True)
+            self.message.emit(str(e), True)
+            self._set_result(-1)
+            return
+
+        self.message.emit(f"Installed as {local_openpype}", False)
+        self.progress.emit(100)
+        self._set_result(1)
+        return
+
         self.progress.emit(100)
         self._set_result(1)
         return