Cleanup unnecessary multiple version system abstraction

client/ayon_perforce/__init__.py

@@ -0,0 +1,14 @@
+"""
+Package for interfacing with version control systems
+"""
+from .addon import (
+    PerforceAddon,
+    is_perforce_enabled,
+    PERFORCE_ADDON_DIR
+)
+
+__all__ = (
+    "PerforceAddon",
+    "is_perforce_enabled",
+    "PERFORCE_ADDON_DIR",
+)

client/version_control/addon.py → client/ayon_perforce/addon.py

@@ -14,45 +14,35 @@
 from .lib import WorkspaceProfileContext
 
 
-VERSION_CONTROL_ADDON_DIR = os.path.dirname(os.path.abspath(__file__))
+PERFORCE_ADDON_DIR = os.path.dirname(os.path.abspath(__file__))
 
 
-class VersionControlAddon(AYONAddon, ITrayService, IPluginPaths):
+class PerforceAddon(AYONAddon, ITrayService, IPluginPaths):
 
-    label = "Version Control"
-    name = "version_control"
+    label = "Perforce"
+    name = "ayon_perforce"
     version = __version__
 
     # _icon_name = "mdi.jira"
     # _icon_scale = 1.3
     webserver = None
-    active_version_control_system = None
 
     # Properties:
     @property
-    def name(self):
-        # type: () -> str
-        return "version_control"
+    def name(self) -> str:
+        return "perforce"
 
     @property
-    def label(self):
-        # type: () -> str
-        return f"Version Control: {self.active_version_control_system.title()}"
+    def label(self) -> str:
+        return f"Perforce Version Control"
 
     # Public Methods:
-    def initialize(self, settings):
-        # type: (dict[str, Any]) -> None
-        assert self.name in settings, (
-            "{} not found in settings - make sure they are defined in the defaults".format(self.name)
-        )
-        vc_settings = settings[self.name]  # type: dict[str, Any]
-        active_version_control_system = vc_settings["active_version_control_system"]  # type: str
-        self.active_version_control_system = active_version_control_system
-        enabled = vc_settings["enabled"]  # type: bool
+    def initialize(self, settings: dict[str, Any]):
+        vc_settings = settings.get(self.name)  # type: dict[str, Any]
+        enabled = vc_settings and vc_settings["enabled"]  # type: bool
         self.set_service_running_icon() if enabled else self.set_service_failed_icon()
 
     def get_global_environments(self):
-        # return {"ACTIVE_VERSION_CONTROL_SYSTEM": self.active_version_control_system}
         return {}
 
     def get_connection_info(
@@ -64,8 +54,8 @@ def get_connection_info(
         if not project_settings:
             project_settings = get_project_settings(project_name)
 
-        version_settings = project_settings["version_control"]
-        local_setting = version_settings["local_setting"]
+        settings = project_settings["perforce"]
+        local_setting = settings["local_setting"]
 
         workspace_name = None
         filtering_criteria = {
@@ -88,22 +78,23 @@ def get_connection_info(
             workspace_name = profile["workspace_name"]
 
         return {
-            "host": version_settings["host_name"],
-            "port": version_settings["port"],
+            "host": settings["host_name"],
+            "port": settings["port"],
             "username": local_setting["username"],
             "password": local_setting["password"],
             "workspace_name": workspace_name
         }
 
     def sync_to_version(self, conn_info, change_id):
-        from version_control.rest.perforce.rest_stub import \
-            PerforceRestStub
-
-        PerforceRestStub.login(host=conn_info["host"],
-                               port=conn_info["port"],
-                               username=conn_info["username"],
-                               password=conn_info["password"],
-                               workspace=conn_info["workspace_dir"])
+        from ayon_perforce.rest.perforce.rest_stub import PerforceRestStub
+
+        PerforceRestStub.login(
+            host=conn_info["host"],
+            port=conn_info["port"],
+            username=conn_info["username"],
+            password=conn_info["password"],
+            workspace=conn_info["workspace_dir"]
+        )
         PerforceRestStub.sync_to_version(
             f"{conn_info['workspace_dir']}/...", change_id)
         return
@@ -118,7 +109,7 @@ def tray_init(self):
 
     def tray_start(self):
         if self.enabled:
-            from version_control.rest.communication_server import WebServer
+            from ayon_perforce.rest.communication_server import WebServer
             self.webserver = WebServer()
             self.webserver.start()
 
@@ -128,11 +119,10 @@ def get_plugin_paths(self):
     def get_create_plugin_paths(self, host_name):
         if host_name != "unreal":
             return []
-        return ["{}/plugins/create/unreal".format(VERSION_CONTROL_ADDON_DIR)]
+        return ["{}/plugins/create/unreal".format(PERFORCE_ADDON_DIR)]
 
     def get_publish_plugin_paths(self, host_name):
-        return [os.path.join(VERSION_CONTROL_ADDON_DIR,
-                             "plugins", "publish")]
+        return [os.path.join(PERFORCE_ADDON_DIR, "plugins", "publish")]
 
     def get_launch_hook_paths(self, _app):
         """Implementation for applications launch hooks.
@@ -141,9 +131,8 @@ def get_launch_hook_paths(self, _app):
             (str): full absolute path to directory with hooks for the module
         """
 
-        return os.path.join(VERSION_CONTROL_ADDON_DIR, "launch_hooks",
-                            self.active_version_control_system)
+        return os.path.join(PERFORCE_ADDON_DIR, "launch_hooks")
 
 
-def is_version_control_enabled(project_settings):
-    return project_settings.get("version_control", {}).get("enabled", False)
+def is_perforce_enabled(project_settings):
+    return project_settings.get("perforce", {}).get("enabled", False)