Create DaikinFactory class

pydaikin/daikin_base.py

@@ -10,7 +10,6 @@
 from aiohttp.web_exceptions import HTTPForbidden
 
 from .discovery import get_name  # pylint: disable=cyclic-import
-from .exceptions import DaikinException
 from .power import (  # pylint: disable=cyclic-import
     ATTR_COOL,
     ATTR_HEAT,
@@ -53,43 +52,6 @@ def daikin_values(cls, dimension):
         """Return sorted list of translated values."""
         return sorted(list(cls.TRANSLATIONS.get(dimension, {}).values()))
 
-    @staticmethod
-    async def factory(device_id, session=None, **kwargs):
-        """Factory to init the corresponding Daikin class."""
-        from .daikin_airbase import (  # pylint: disable=import-outside-toplevel,cyclic-import
-            DaikinAirBase,
-        )
-        from .daikin_brp069 import (  # pylint: disable=import-outside-toplevel,cyclic-import
-            DaikinBRP069,
-        )
-        from .daikin_brp072c import (  # pylint: disable=import-outside-toplevel,cyclic-import
-            DaikinBRP072C,
-        )
-        from .daikin_skyfi import (  # pylint: disable=import-outside-toplevel,cyclic-import
-            DaikinSkyFi,
-        )
-
-        if 'password' in kwargs and kwargs['password'] is not None:
-            appl = DaikinSkyFi(device_id, session, password=kwargs['password'])
-        elif 'key' in kwargs and kwargs['key'] is not None:
-            appl = DaikinBRP072C(
-                device_id,
-                session,
-                key=kwargs['key'],
-                uuid=kwargs.get('uuid'),
-            )
-        else:  # special case for BRP069 and AirBase
-            appl = DaikinBRP069(device_id, session)
-            await appl.update_status(appl.HTTP_RESOURCES[:1])
-            if appl.values == {}:
-                appl = DaikinAirBase(device_id, session)
-        await appl.init()
-        if not appl.values.get("mode"):
-            raise DaikinException(
-                f"Error creating device, {device_id} is not supported."
-            )
-        return appl
-
     @staticmethod
     def parse_response(response_body):
         """Parse response from Daikin."""

pydaikin/factory.py

@@ -0,0 +1,57 @@
+"Factory to generate Pydaikin complete objects"
+
+from typing import Optional
+
+from aiohttp import ClientSession
+
+from .daikin_airbase import DaikinAirBase
+from .daikin_base import Appliance
+from .daikin_brp069 import DaikinBRP069
+from .daikin_brp072c import DaikinBRP072C
+from .daikin_skyfi import DaikinSkyFi
+from .exceptions import DaikinException
+
+
+class DaikinFactory:  # pylint: disable=too-few-public-methods
+    "Factory object generating instantiated instances of Appliance"
+    _generated_object: Appliance
+
+    async def __new__(cls, *a, **kw):  # pylint: disable=invalid-overridden-method
+        "Return not itself, but the Appliance instanced by __init__"
+        instance = super().__new__(cls)
+        await instance.__init__(*a, **kw)
+        return instance._generated_object
+
+    async def __init__(
+        self,
+        device_id: str,
+        session: Optional[ClientSession],
+        password: str = None,
+        key: str = None,
+        **kwargs,
+    ) -> None:
+        """Factory to init the corresponding Daikin class."""
+
+        if password is not None:
+            self._generated_object = DaikinSkyFi(device_id, session, password=password)
+        elif key is not None:
+            self._generated_object = DaikinBRP072C(
+                device_id,
+                session,
+                key=key,
+                uuid=kwargs.get('uuid'),
+            )
+        else:  # special case for BRP069 and AirBase
+            self._generated_object = DaikinBRP069(device_id, session)
+            await self._generated_object.update_status(
+                self._generated_object.HTTP_RESOURCES[:1]
+            )
+            if self._generated_object.values == {}:
+                self._generated_object = DaikinAirBase(device_id, session)
+
+        await self._generated_object.init()
+
+        if not self._generated_object.values.get("mode"):
+            raise DaikinException(
+                f"Error creating device, {device_id} is not supported."
+            )