plugp100 5.0.0.dev4__tar.gz → 5.0.0.dev6__tar.gz

plugp100-5.0.0.dev6/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.1
+Name: plugp100
+Version: 5.0.0.dev6
+Summary: Controller for TP-Link Tapo P100 and other devices
+Home-page: https://github.com/petretiandrea/plugp100
+Download-URL: https://github.com/petretiandrea/plugp100
+Author: @petretiandrea
+Author-email: petretiandrea@gmail.com
+License: GPL3
+Keywords: Tapo,P100
+Classifier: Development Status :: 5 - Production/Stable
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi>=2021.5.30
+Requires-Dist: jsons>=1.6.3
+Requires-Dist: requests>=2.27.1
+Requires-Dist: aiohttp>=3.8.1
+Requires-Dist: semantic-version==2.10.0
+Requires-Dist: cryptography>=38.0.3
+Requires-Dist: scapy>=2.5.0
+Requires-Dist: urllib3<2,>=1.26.5
+
+# Plug P100
+This is a fork of original work of [@K4CZP3R](https://github.com/K4CZP3R/tapo-p100-python)
+
+The purpose of this fork is to provide the library as PyPi package. 
+
+# How to install
+```pip install plugp100```
+
+## Library Architecture
+The library was rewritten by taking inspiration from [Component Gaming Design Pattern](https://gameprogrammingpatterns.com/component.html) to achieve better decoupling from device and its capabilities.
+Each Tapo Device, now, is something like a container of Device Component. A Device Component represent a specific feature, so a Tapo Device can be composed by multiple device component.
+e.g. `EnergyComponent`, `OverheatComponent`, `OnOffComponent` and so on.
+
+There 3 main Tapo Device class family, which simplify access to underlying components:
+- TapoBulb
+- TapoPlug
+- TapoHub
+
+
+## Supported Devices
+
+This library supports a wide range of Tapo devices, including:
+
+- Tapo Smart Plugs
+- Tapo Smart Plug Strip
+- Tapo Smart Led Strip
+- Tapo Smart Bulb
+- Tapo HUB H100
+  - Water Leak
+  - Trigger Button (like S200)
+  - Switch
+  - Smart Door
+  - Temperature Humidity Sensor
+
+Every device class has more than one component which enrich the basic capability of Tapo Device. 
+You can see the supported components inside `plugp100/new/components` package.
+
+
+## Usage
+
+Replace `<tapo_username>`, `<tapo_password>`, and `<tapo_device_ip>` with your Tapo account credentials and device IP address.
+
+### Authentication
+
+Before using the library, make sure to have your Tapo credentials ready:
+
+```python
+from plugp100.common.credentials import AuthCredential
+
+credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+```
+
+### Example: Discovery
+
+Use the library to discover Tapo devices on the network:
+
+```python
+import asyncio
+import logging
+from plugp100.common.credentials import AuthCredential
+from plugp100.discovery.tapo_discovery import TapoDiscovery
+
+async def example_discovery(credentials: AuthCredential):
+    discovered = await TapoDiscovery.scan(timeout=5)
+    for discovered_device in discovered:
+        try:
+            device = await discovered_device.get_tapo_device(credentials)
+            await device.update()
+            print({
+                'type': type(device),
+                'protocol': device.protocol_version,
+                'raw_state': device.raw_state
+            })
+            await device.client.close()
+        except Exception as e:
+            logging.error(f"Failed to update {discovered_device.ip} {discovered_device.device_type}", exc_info=e)
+
+async def main():
+    credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+    await example_discovery(credentials)
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())
+    loop.run_until_complete(asyncio.sleep(0.1))
+    loop.close()
+```
+
+### Example: Connecting by only ip address
+
+Connect to a Tapo device without knowing its device type and protocol. The library will try to guess:
+
+```python
+import asyncio
+from plugp100.common.credentials import AuthCredential
+from plugp100.new.device_factory import connect, DeviceConnectConfiguration
+
+async def example_connect_by_guessing(credentials: AuthCredential, host: str):
+    device_configuration = DeviceConnectConfiguration(
+        host=host,
+        credentials=credentials
+    )
+    device = await connect(device_configuration)
+    await device.update()
+    print({
+        'type': type(device),
+        'protocol': device.protocol_version,
+        'raw_state': device.raw_state,
+        'components': device.get_device_components
+    })
+
+async def main():
+    credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+    await example_connect_by_guessing(credentials, "<tapo_device_ip>")
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())
+    loop.run_until_complete(asyncio.sleep(0.1))
+    loop.close()
+```
+
+### Example: Connecting by knowing Protocol
+
+Connect to a Tapo device with known device type and protocol details:
+
+```python
+import asyncio
+from plugp100.common.credentials import AuthCredential
+from plugp100.new.device_factory import connect, DeviceConnectConfiguration
+
+async def example_connect_knowing_device_and_protocol(credentials: AuthCredential, host: str):
+    device_configuration = DeviceConnectConfiguration(
+        host=host,
+        credentials=credentials,
+        device_type="SMART.TAPOPLUG",
+        encryption_type="klap",
+        encryption_version=2
+    )
+    device = await connect(device_configuration)
+    await device.update()
+    print({
+        'type': type(device),
+        'protocol': device.protocol_version,
+        'raw_state': device.raw_state,
+        'components': device.get_device_components
+    })
+
+async def main():
+    credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+    await example_connect_knowing_device_and_protocol(credentials, "<tapo_device_ip>")
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())
+    loop.run_until_complete(asyncio.sleep(0.1))
+    loop.close()
+```
+
+
+
+## Supported Protocols
+
+- Klap v1
+- Klap v2
+- Passthorugh
+- Ipcamera-like?! (work in progress hub H200)

plugp100-5.0.0.dev6/README.md

@@ -0,0 +1,167 @@
+# Plug P100
+This is a fork of original work of [@K4CZP3R](https://github.com/K4CZP3R/tapo-p100-python)
+
+The purpose of this fork is to provide the library as PyPi package. 
+
+# How to install
+```pip install plugp100```
+
+## Library Architecture
+The library was rewritten by taking inspiration from [Component Gaming Design Pattern](https://gameprogrammingpatterns.com/component.html) to achieve better decoupling from device and its capabilities.
+Each Tapo Device, now, is something like a container of Device Component. A Device Component represent a specific feature, so a Tapo Device can be composed by multiple device component.
+e.g. `EnergyComponent`, `OverheatComponent`, `OnOffComponent` and so on.
+
+There 3 main Tapo Device class family, which simplify access to underlying components:
+- TapoBulb
+- TapoPlug
+- TapoHub
+
+
+## Supported Devices
+
+This library supports a wide range of Tapo devices, including:
+
+- Tapo Smart Plugs
+- Tapo Smart Plug Strip
+- Tapo Smart Led Strip
+- Tapo Smart Bulb
+- Tapo HUB H100
+  - Water Leak
+  - Trigger Button (like S200)
+  - Switch
+  - Smart Door
+  - Temperature Humidity Sensor
+
+Every device class has more than one component which enrich the basic capability of Tapo Device. 
+You can see the supported components inside `plugp100/new/components` package.
+
+
+## Usage
+
+Replace `<tapo_username>`, `<tapo_password>`, and `<tapo_device_ip>` with your Tapo account credentials and device IP address.
+
+### Authentication
+
+Before using the library, make sure to have your Tapo credentials ready:
+
+```python
+from plugp100.common.credentials import AuthCredential
+
+credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+```
+
+### Example: Discovery
+
+Use the library to discover Tapo devices on the network:
+
+```python
+import asyncio
+import logging
+from plugp100.common.credentials import AuthCredential
+from plugp100.discovery.tapo_discovery import TapoDiscovery
+
+async def example_discovery(credentials: AuthCredential):
+    discovered = await TapoDiscovery.scan(timeout=5)
+    for discovered_device in discovered:
+        try:
+            device = await discovered_device.get_tapo_device(credentials)
+            await device.update()
+            print({
+                'type': type(device),
+                'protocol': device.protocol_version,
+                'raw_state': device.raw_state
+            })
+            await device.client.close()
+        except Exception as e:
+            logging.error(f"Failed to update {discovered_device.ip} {discovered_device.device_type}", exc_info=e)
+
+async def main():
+    credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+    await example_discovery(credentials)
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())
+    loop.run_until_complete(asyncio.sleep(0.1))
+    loop.close()
+```
+
+### Example: Connecting by only ip address
+
+Connect to a Tapo device without knowing its device type and protocol. The library will try to guess:
+
+```python
+import asyncio
+from plugp100.common.credentials import AuthCredential
+from plugp100.new.device_factory import connect, DeviceConnectConfiguration
+
+async def example_connect_by_guessing(credentials: AuthCredential, host: str):
+    device_configuration = DeviceConnectConfiguration(
+        host=host,
+        credentials=credentials
+    )
+    device = await connect(device_configuration)
+    await device.update()
+    print({
+        'type': type(device),
+        'protocol': device.protocol_version,
+        'raw_state': device.raw_state,
+        'components': device.get_device_components
+    })
+
+async def main():
+    credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+    await example_connect_by_guessing(credentials, "<tapo_device_ip>")
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())
+    loop.run_until_complete(asyncio.sleep(0.1))
+    loop.close()
+```
+
+### Example: Connecting by knowing Protocol
+
+Connect to a Tapo device with known device type and protocol details:
+
+```python
+import asyncio
+from plugp100.common.credentials import AuthCredential
+from plugp100.new.device_factory import connect, DeviceConnectConfiguration
+
+async def example_connect_knowing_device_and_protocol(credentials: AuthCredential, host: str):
+    device_configuration = DeviceConnectConfiguration(
+        host=host,
+        credentials=credentials,
+        device_type="SMART.TAPOPLUG",
+        encryption_type="klap",
+        encryption_version=2
+    )
+    device = await connect(device_configuration)
+    await device.update()
+    print({
+        'type': type(device),
+        'protocol': device.protocol_version,
+        'raw_state': device.raw_state,
+        'components': device.get_device_components
+    })
+
+async def main():
+    credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+    await example_connect_knowing_device_and_protocol(credentials, "<tapo_device_ip>")
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())
+    loop.run_until_complete(asyncio.sleep(0.1))
+    loop.close()
+```
+
+
+
+## Supported Protocols
+
+- Klap v1
+- Klap v2
+- Passthorugh
+- Ipcamera-like?! (work in progress hub H200)

{plugp100-5.0.0.dev4 → plugp100-5.0.0.dev6}/plugp100/__init__.py

@@ -16,4 +16,4 @@ from plugp100.api.requests import *
 from plugp100.api import *
 from plugp100.common import *
 
-__version__ = "5.0.0-dev.4"
+__version__ = "5.0.0-dev.6"

{plugp100-5.0.0.dev4 → plugp100-5.0.0.dev6}/plugp100/discovery/__init__.py

@@ -1,4 +1,4 @@
-from .discovered_device import DiscoveredDevice, EncryptionScheme
+from .discovered_device import DiscoveredDevice, EncryptionSchema
 from .tapo_discovery import TapoDiscovery
 
-__all__ = ["TapoDiscovery", "DiscoveredDevice", "EncryptionScheme"]
+__all__ = ["TapoDiscovery", "DiscoveredDevice", "EncryptionSchema"]

{plugp100-5.0.0.dev4 → plugp100-5.0.0.dev6}/plugp100/discovery/discovered_device.py

@@ -1,4 +1,5 @@
 import dataclasses
+import logging
 from typing import Optional, Any
 
 import aiohttp
@@ -14,7 +15,7 @@ class DiscoveredDevice:
     device_model: str
     ip: str
     mac: str
-    mgt_encrypt_schm: "EncryptionScheme"
+    mgt_encrypt_schm: Optional["EncryptionSchema"]
 
     device_id: Optional[str] = None
     owner: Optional[str] = None
@@ -25,6 +26,10 @@ class DiscoveredDevice:
 
     @staticmethod
     def from_dict(values: dict[str, Any]) -> "DiscoveredDevice":
+        if enc_schema_info := values.get("mgt_encrypt_schm", None):
+            encryption_schema = EncryptionSchema(**enc_schema_info)
+        else:
+            encryption_schema = None
         return DiscoveredDevice(
             device_type=values.get("device_type", values.get("device_type_text")),
             device_model=values.get("device_model", values.get("model")),
@@ -36,7 +41,7 @@ class DiscoveredDevice:
             is_support_iot_cloud=values.get("is_support_iot_cloud", None),
             obd_src=values.get("obd_src", None),
             factory_default=values.get("factory_default", None),
-            mgt_encrypt_schm=EncryptionScheme(**values.get("mgt_encrypt_schm")),
+            mgt_encrypt_schm=encryption_schema,
         )
 
     @property
@@ -56,25 +61,42 @@ class DiscoveredDevice:
                 "encrypt_type": self.mgt_encrypt_schm.encrypt_type,
                 "http_port": self.mgt_encrypt_schm.http_port,
                 "lv": self.mgt_encrypt_schm.lv,
-            },
+            }
+            if self.mgt_encrypt_schm is not None
+            else None,
         }
 
     async def get_tapo_device(
         self, credentials: AuthCredential, session: Optional[aiohttp.ClientSession] = None
     ) -> TapoDevice:
-        config = DeviceConnectConfiguration(
-            host=self.ip,
-            port=self.mgt_encrypt_schm.http_port,
-            credentials=credentials,
-            device_type=self.device_type,
-            encryption_type=self.mgt_encrypt_schm.encrypt_type,
-            encryption_version=self.mgt_encrypt_schm.lv,
-        )
+        if encrypt_schema := self.mgt_encrypt_schm:
+            port = (
+                encrypt_schema.http_port or 443
+                if encrypt_schema.is_support_https
+                else encrypt_schema.http_port
+            )
+            config = DeviceConnectConfiguration(
+                host=self.ip,
+                port=port,
+                credentials=credentials,
+                device_type=self.device_type,
+                encryption_type=encrypt_schema.encrypt_type,
+                encryption_version=encrypt_schema.lv,
+            )
+        else:
+            logging.warning(
+                "No encryption schema found for discovered device {}, {}",
+                self.ip,
+                self.device_type,
+            )
+            config = DeviceConnectConfiguration(
+                host=self.ip, port=80, device_type=self.device_type
+            )
         return await connect(config, session)
 
 
 @dataclasses.dataclass
-class EncryptionScheme:
+class EncryptionSchema:
     """Base model for encryption scheme of discovery result."""
 
     is_support_https: Optional[bool] = None

{plugp100-5.0.0.dev4 → plugp100-5.0.0.dev6}/plugp100/discovery/tapo_discovery.py

@@ -82,7 +82,6 @@ class TapoDiscovery:
             None,
             lambda: list(TapoDiscovery(broadcast, port, timeout)._scan()),
         )
-        print(devices_found)
         return [DiscoveredDevice.from_dict(x) for x in devices_found]
 
     @staticmethod

plugp100-5.0.0.dev6/plugp100/example.py

@@ -0,0 +1,81 @@
+import asyncio
+import logging
+
+from plugp100.common.credentials import AuthCredential
+from plugp100.discovery.tapo_discovery import TapoDiscovery
+from plugp100.new.device_factory import connect, DeviceConnectConfiguration
+
+
+# Example get device from discovery
+async def example_discovery(credentials: AuthCredential):
+    discovered = await TapoDiscovery.scan(timeout=5)
+    for discovered_device in discovered:
+        try:
+            device = await discovered_device.get_tapo_device(credentials)
+            await device.update()
+            print(
+                {
+                    "type": type(device),
+                    "protocol": device.protocol_version,
+                    "raw_state": device.raw_state,
+                }
+            )
+            await device.client.close()
+        except Exception as e:
+            logging.error(
+                f"Failed to update {discovered_device.ip} {discovered_device.device_type}",
+                exc_info=e,
+            )
+
+
+# Example by knowing protocol details and device class
+async def example_connect_knowing_device_and_protocol(
+    credentials: AuthCredential, host: str
+):
+    device_configuration = DeviceConnectConfiguration(
+        host=host,
+        credentials=credentials,
+        device_type="SMART.TAPOPLUG",
+        encryption_type="klap",
+        encryption_version=2,
+    )
+    device = await connect(device_configuration)
+    await device.update()
+    print(
+        {
+            "type": type(device),
+            "protocol": device.protocol_version,
+            "raw_state": device.raw_state,
+            "components": device.get_device_components,
+        }
+    )
+
+
+# Example without knowing device class and protocol. The library will try
+# to get info to establish protocol and device class
+async def example_connect_by_guessing(credentials: AuthCredential, host: str):
+    device_configuration = DeviceConnectConfiguration(host=host, credentials=credentials)
+    device = await connect(device_configuration)
+    await device.update()
+    print(
+        {
+            "type": type(device),
+            "protocol": device.protocol_version,
+            "raw_state": device.raw_state,
+            "components": device.get_device_components,
+        }
+    )
+
+
+async def main():
+    credentials = AuthCredential("<tapo_username>", "<tapo_password>")
+    await example_discovery(credentials)
+    await example_connect_knowing_device_and_protocol(credentials, "<tapo_device_ip>")
+    await example_connect_by_guessing(credentials, "<tapo_device_ip>")
+
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(main())
+    loop.run_until_complete(asyncio.sleep(0.1))
+    loop.close()

{plugp100-5.0.0.dev4 → plugp100-5.0.0.dev6}/plugp100/new/components/energy_component.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Any
 
 from plugp100.api.tapo_client import TapoClient
 from plugp100.new.components.device_component import DeviceComponent
@@ -12,7 +12,7 @@ class EnergyComponent(DeviceComponent):
         self._energy_usage = None
         self._power_info = None
 
-    async def update(self, **kwargs):
+    async def update(self, current_state: dict[str, Any] | None = None):
         energy_usage = await self._client.get_energy_usage()
         power_info = await self._client.get_current_power()
         self._energy_usage = energy_usage.value if energy_usage.is_success() else None

{plugp100-5.0.0.dev4 → plugp100-5.0.0.dev6}/plugp100/new/device_factory.py

@@ -39,8 +39,8 @@ class DeviceConnectConfiguration:
 async def connect(
     config: DeviceConnectConfiguration, session: Optional[aiohttp.ClientSession] = None
 ):
-    protocol = await _get_or_guess_protocol(config, session)
     if config.device_type is None:
+        protocol = await _get_or_guess_protocol(config, session)
         _LOGGER.info(
             "Not enough information to detected device type and model, trying to fetching from device..."
         )
@@ -52,6 +52,8 @@ async def connect(
         factory = _get_device_class_from_model_type(device_info.type)
     else:
         factory = _get_device_class_from_model_type(config.device_type)
+        protocol = await _get_or_guess_protocol(config, session)
+
     client = TapoClient(config.credentials, config.url, protocol, session)
     return factory(config.host, config.port, client)
 
@@ -108,4 +110,6 @@ def _get_device_class_from_model_type(device_type: str) -> Type[TapoDevice]:
         return TapoBulb
     elif device_type == "SMART.TAPOHUB":
         return TapoHub
+    elif device_type == "SMART.IPCAMERA":
+        raise Exception(f"Device of type {device_type} not supported!")
     return TapoDevice

{plugp100-5.0.0.dev4 → plugp100-5.0.0.dev6}/plugp100/responses/child_device_list.py

@@ -52,7 +52,7 @@ class ChildDeviceList(object):
         )
 
     def get_next_index(self) -> int:
-        return self.start_index + len(self.child_device_list) + 1
+        return self.start_index + len(self.child_device_list)
 
     def has_next(self) -> bool:
         return self.get_next_index() < self.sum