tb-rest-client 3.6__tar.gz → 3.6.3__tar.gz

tb-rest-client-3.6.3/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: tb-rest-client
+Version: 3.6.3
+Summary: ThingsBoard REST API client
+Home-page: https://thingsboard.io/docs/reference/python-rest-client/
+Download-URL: https://github.com/thingsboard/thingsboard-python-rest-client/archive/refs/tags/3.6.3.tar.gz
+Author-email: info@thingsboard.io
+License: Apache Software License (Apache Software License 2.0)
+Keywords: IoT,ThingsBoard,ThingsBoard REST API client
+Requires-Python: >=3.7
+License-File: LICENSE
+
+# ThingsBoard Python REST API client
+
+
+The ThingsBoard REST API Client helps you interact with [ThingsBoard REST API](https://thingsboard.io/docs/reference/rest-api/) from your Python script.  
+With [Python Rest Client](https://thingsboard.io/docs/reference/python-rest-client/) you can programmatically create assets, devices, customers, users and other entities and their relations in ThingsBoard.
+
+The recommended method for installing the Rest Client is a pip.  
+
+*The Python version of the REST API client is under developing. If you have discovered any bug, please write us using email or by opening the issue.*
+
+
+##### Installation 
+
+In order to install the ThingsBoard REST client, you should use the following command:
+
+```bash
+pip3 install tb-rest-client
+``` 
+
+
+##### Examples 
+
+You can find the examples of the usage in the "examples" folder or on the [our website](https://thingsboard.io/docs/reference/python-rest-client/).
+
+
+**Note:** There are 2 REST clients for ThingsBoard, they are depend on version of the ThingsBoard, you use.  
+
+ - If you use the ThingsBoard Community Edition (ThingsBoard CE) - please use the following command to import the REST client into your script:  
+   `from tb_rest_client.rest_client_ce import *`  
+   The REST client class has name "RestClientCE".  
+   
+ - If you use the ThingsBoard Professional Edition (ThingsBoard PE) - please use the following command to import the REST client into your script:  
+   `from tb_rest_client.rest_client_pe import *`  
+   The REST client class has name "RestClientPE".  
+
+If you use the wrong version of the REST client, it could work unexpectedly.
+
+
+## Support
+
+ - [Community chat](https://gitter.im/thingsboard/chat)
+ - [Q&A forum](https://groups.google.com/forum/#!forum/thingsboard)
+ - [Stackoverflow](http://stackoverflow.com/questions/tagged/thingsboard)
+ 
+**Don't forget to star the repository to show your ❤️ and support.**
+
+
+## Licenses
+
+This project is released under [Apache 2.0 License](./LICENSE).

tb-rest-client-3.6.3/examples/__init__.py

@@ -0,0 +1,15 @@
+#  Copyright 2024. ThingsBoard
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+

tb-rest-client-3.6.3/examples/configure_vcs_access.py

@@ -0,0 +1,92 @@
+#  Copyright 2024. ThingsBoard
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import logging
+from argparse import ArgumentParser
+from os.path import pathsep
+
+from tb_rest_client.models.models_ce.repository_settings import RepositorySettings
+from tb_rest_client.rest import ApiException
+from tb_rest_client.rest_client_ce import RestClientCE
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(levelname)s - %(module)s - %(lineno)d - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+
+def main(github_password, private_key, private_key_password, user: str, password: str, host: str = "localhost",
+         port: int = 80, default_branch: str = "", repository_uri: str = "", github_username: str = ""):
+    url = host
+    if "https://" not in host:
+        if "http://" not in host:
+            if port != 443:
+                url = "http://" + host + ":" + str(port)
+            else:
+                url = "https://" + host + ":443"
+
+    with RestClientCE(base_url=url) as rest_client:
+        try:
+            # Auth with credentials
+            logging.info("Logging in...")
+            rest_client.login(username=user, password=password)
+            logging.info("Logged in.")
+
+            auth_method = "USERNAME_PASSWORD"
+            private_key_file_name = None
+
+            if private_key:
+                auth_method = "PRIVATE_KEY"
+                private_key_file_name = private_key.split(pathsep)[-1]
+                with open(private_key, "r") as pkf:
+                    private_key = pkf.read()
+
+            repository_settings_config = {
+                "auth_method": auth_method,
+                "default_branch": default_branch,
+                "password": github_password,
+                "private_key": private_key,
+                "private_key_file_name": private_key_file_name,
+                "private_key_password": private_key_password,
+                "repository_uri": repository_uri,
+                "username": github_username
+            }
+
+            repository_settings = RepositorySettings(**repository_settings_config)
+
+            saved_repository_settings = rest_client.save_repository_settings(repository_settings)
+
+            logging.info(f"Saved repository settings: {saved_repository_settings}")
+
+        except ApiException as e:
+            logging.exception(e)
+
+
+if __name__ == '__main__':
+    parser = ArgumentParser(description="""
+    Using this script you can configure version control system on ThingsBoard.""")
+    parser.add_argument("-U", "--user", help="User email to login into ThingsBoard", required=True)
+    parser.add_argument("-P", "--password", help="User password to login into ThingsBoard", required=True)
+
+    parser.add_argument("-H", "--host", help="ThingsBoard host", default="localhost")
+    parser.add_argument("-p", "--port", help="ThingsBoard port", type=int, default=80)
+
+    parser.add_argument("-b", "--default_branch", help="Default branch on repository", type=str, default="main")
+    parser.add_argument("-r", "--repository_uri", help="Repository url", type=str, default="", required=True)
+    parser.add_argument("-gu", "--github_username", help="GitHub username", type=str, default="", required=True)
+    parser.add_argument("-gp", "--github_password", help="Github password", type=str, default="")
+    parser.add_argument("-pk", "--private_key", help="Path to private key", type=str, default="")
+    parser.add_argument("-pkp", "--private_key_password", help="Private key password", type=str, default="")
+
+    args = parser.parse_args()
+    main(**args.__dict__)

tb-rest-client-3.6.3/examples/example_application.py

@@ -0,0 +1,71 @@
+#  Copyright 2024. ThingsBoard
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+import logging
+# Importing models and REST client class from Community Edition version
+from tb_rest_client.rest_client_ce import *
+from tb_rest_client.rest import ApiException
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(levelname)s - %(module)s - %(lineno)d - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+# ThingsBoard REST API URL
+url = "http://localhost:8080"
+
+# Default Tenant Administrator credentials
+username = "tenant@thingsboard.org"
+password = "tenant"
+
+
+def main():
+    # Creating the REST client object with context manager to get auto token refresh
+    with RestClientCE(base_url=url) as rest_client:
+        try:
+            # Auth with credentials
+            rest_client.login(username=username, password=password)
+
+            # Creating an Asset
+            default_asset_profile_id = rest_client.get_default_asset_profile_info().id
+            asset = Asset(name="Building 1", label="Building 1",
+                          asset_profile_id=default_asset_profile_id)
+            asset = rest_client.save_asset(asset)
+
+            logging.info("Asset was created:\n%r\n", asset)
+
+            # Creating a Device
+            # Also, you can use default Device Profile:
+            # default_device_profile_id = rest_client.get_default_device_profile_info().id
+            device_profile = DeviceProfile(name="Thermometer",
+                                           profile_data=DeviceProfileData(configuration={"type": "DEFAULT"},
+                                                                          transport_configuration={"type": "DEFAULT"}))
+            device_profile = rest_client.save_device_profile(device_profile)
+            device = Device(name="Thermometer 1", label="Thermometer 1",
+                            device_profile_id=device_profile.id)
+            device = rest_client.save_device(device)
+
+            logging.info(" Device was created:\n%r\n", device)
+
+            # Creating relations from device to asset
+            relation = EntityRelation(_from=asset.id, to=device.id, type="Contains")
+            rest_client.save_relation(relation)
+
+            logging.info(" Relation was created:\n%r\n", relation)
+        except ApiException as e:
+            logging.exception(e)
+
+
+if __name__ == '__main__':
+    main()

tb-rest-client-3.6.3/examples/example_application_2.py

@@ -0,0 +1,113 @@
+#  Copyright 2024. ThingsBoard
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+import logging
+from json import load
+# Importing models and REST client class from Professional Edition version
+from tb_rest_client.rest_client_pe import *
+from tb_rest_client.rest import ApiException
+
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(levelname)s - %(module)s - %(lineno)d - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+
+# ThingsBoard REST API URL
+url = "http://localhost:8080"
+
+# Default Tenant Administrator credentials
+username = "tenant@thingsboard.org"
+password = "tenant"
+
+
+# Creating the REST client object with context manager to get auto token refresh
+def main():
+    with RestClientPE(base_url=url) as rest_client:
+        try:
+            # Auth with credentials
+            rest_client.login(username=username, password=password)
+
+            # Getting current user
+            current_user = rest_client.get_user()
+
+            # Creating Dashboard Group on the Tenant Level
+            shared_dashboards_group = EntityGroup(name="Shared Dashboards3", type="DASHBOARD")
+            shared_dashboards_group = rest_client.save_entity_group(shared_dashboards_group)
+            logging.info('Dashboard group created:\n%r\n', shared_dashboards_group)
+
+            # Loading Dashboard from file
+            dashboard_json = None
+            with open("watermeters.json", "r") as dashboard_file:
+                dashboard_json = load(dashboard_file)
+            dashboard = Dashboard(title=dashboard_json["title"], configuration=dashboard_json["configuration"])
+            dashboard = rest_client.save_dashboard(dashboard)
+            logging.info('Dashboard created:\n%r\n', dashboard)
+
+            # Adding Dashboard to the Shared Dashboards Group
+            dashboard = list(filter(lambda x: x.name == dashboard.name,
+                                             rest_client.get_user_dashboards(10, 0).data))[0]
+            rest_client.add_entities_to_entity_group(shared_dashboards_group.id, [dashboard.id.id])
+
+            # Creating Customer 1
+            customer1 = Customer(title="Customer 11")
+            customer1 = rest_client.save_customer(body=customer1)
+
+            # Creating Device
+            default_device_profile_id = rest_client.get_default_device_profile_info().id
+            device = Device(name="WaterMeter 1", label="WaterMeter 1", device_profile_id=default_device_profile_id)
+            device = rest_client.save_device(device)
+            logging.info('Device created:\n%r\n', device)
+
+            # Fetching automatically created "Customer Administrators" Group.
+            customer1_administrators = rest_client.get_entity_group_by_owner_and_name_and_type(customer1.id, "USER", "Customer Administrators")
+
+            # Creating Read-Only Role
+            read_only_role = Role(name="Read-Only", permissions=['READ', 'READ_ATTRIBUTES', 'READ_TELEMETRY', 'READ_CREDENTIALS'], type="GROUP")
+            read_only_role = rest_client.save_role(read_only_role)
+            logging.info('Role created:\n%r\n', read_only_role)
+
+            # Assigning Shared Dashboards to the Customer 1 Administrators
+            tenant_id = current_user.tenant_id
+            group_permission = GroupPermission(role_id=read_only_role.id,
+                                               name="Read Only Permission",
+                                               user_group_id=customer1_administrators.id,
+                                               tenant_id=tenant_id,
+                                               entity_group_id=shared_dashboards_group.id,
+                                               entity_group_type=shared_dashboards_group.type)
+            group_permission = rest_client.save_group_permission(group_permission)
+            logging.info('Group permission created:\n%r\n', group_permission)
+
+            # Creating User for Customer 1 with default dashboard from Tenant "Shared Dashboards" group.
+            user_email = "user@thingsboard.org"
+            user_password = "secret"
+            additional_info = {
+                "defaultDashboardId": dashboard.id.id,
+                "defaultDashboardFullscreen": False
+            }
+            user = User(authority="CUSTOMER_USER",
+                        customer_id=customer1.id,
+                        email=user_email,
+                        additional_info=additional_info)
+            user = rest_client.save_user(user, send_activation_mail=False)
+            rest_client.activate_user(body=ActivateUserRequest(user.id, user_password), send_activation_mail=False)
+
+            rest_client.add_entities_to_entity_group(customer1_administrators.id, [user.id.id])
+            logging.info('User created:\n%r\n', user)
+        except ApiException as e:
+            logging.exception(e)
+
+if __name__ == '__main__':
+    main()

tb-rest-client-3.6.3/examples/load_all_entities_from_vcs_ce.py

@@ -0,0 +1,122 @@
+#  Copyright 2024. ThingsBoard
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import logging
+from argparse import ArgumentParser
+from random import choice
+from string import hexdigits
+from time import sleep
+
+from tb_rest_client.models.models_ce import EntityVersion, EntityTypeVersionLoadConfig, EntityTypeVersionLoadRequest
+from tb_rest_client.rest import ApiException
+from tb_rest_client.rest_client_ce import RestClientCE
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(levelname)s - %(module)s - %(lineno)d - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+
+def main(user: str, password: str, host: str = "localhost", port: int = 80, branch: str = "main",
+         find_existing_entity_by_name: bool = True,
+         load_attributes: bool = True, load_credentials: bool = True, load_relations: bool = True,
+         remove_other_entities: bool = True,
+         version_name=None):
+    url = host
+    if "https://" not in host:
+        if "http://" not in host:
+            if port != 443:
+                url = "http://" + host + ":" + str(port)
+            else:
+                url = "https://" + host + ":443"
+
+    with RestClientCE(base_url=url) as rest_client:
+        try:
+            # Auth with credentials
+            logging.info("Logging in...")
+            rest_client.login(username=user, password=password)
+            logging.info("Logged in.")
+
+            if version_name is None:
+                version_name = "".join(choice(hexdigits) for _ in range(5))
+
+            request_config_parameters = {
+                "find_existing_entity_by_name": find_existing_entity_by_name,
+                "load_attributes": load_attributes,
+                "load_credentials": load_credentials,
+                "load_relations": load_relations,
+                "remove_other_entities": remove_other_entities
+            }
+
+            if not [b for b in rest_client.list_branches() if branch in b['name']]:
+                logging.error("Branch not found!")
+                exit(1)
+
+            versions = rest_client.list_versions(branch, 1000, 0)
+            target_versions = [version for version in versions['data'] if version_name in version['name']]
+
+            target_version = target_versions[0]
+            if len(target_versions) > 1:
+                logging.warning(f"\nFound more than one version:\n {target_versions}\n")
+                target_version_index = -1
+                while 0 < target_version_index < len(target_versions):
+                    target_version_index = int(input(f"Please choose the version (1..{len(target_versions)})"))
+                target_version = target_versions[target_version_index - 1]
+
+            logging.info("Restoring version with name: %r", version_name)
+            # Create load version request for previous version
+
+            entities_at_previous_version = rest_client.list_all_entities_at_version(target_version['id'])
+            previous_version_entity_types = set(
+                [entity_obj['externalId']['entityType'] for entity_obj in entities_at_previous_version])
+
+            version_load_request_config = EntityTypeVersionLoadConfig(**request_config_parameters)
+            entity_type_version_load_request_config = {entity_type: version_load_request_config for entity_type in
+                                                       previous_version_entity_types}
+            previous_version_load_request = EntityTypeVersionLoadRequest(entity_type_version_load_request_config,
+                                                                         "ENTITY_TYPE", target_version['id'])
+
+            load_request_id = rest_client.load_entities_version(previous_version_load_request)
+
+            load_request_status = rest_client.get_version_load_request_status(load_request_id)
+            # Wait for restoring and check status
+            while not isinstance(load_request_status, EntityVersion) and not load_request_status.done:
+                load_request_status = rest_client.get_version_load_request_status(load_request_id)
+                sleep(1)
+
+            logging.info("Version load result: %r", load_request_status)
+        except ApiException as e:
+            logging.exception(e)
+
+
+if __name__ == '__main__':
+    parser = ArgumentParser(description="""
+    This script creates new version of all available entities and loads it from version control system.""")
+    parser.add_argument("-U", "--user", help="User email to login into ThingsBoard", required=True)
+    parser.add_argument("-P", "--password", help="User password to login into ThingsBoard", required=True)
+
+    parser.add_argument("-H", "--host", help="ThingsBoard host", default="localhost")
+    parser.add_argument("-p", "--port", help="ThingsBoard port", type=int, default=80)
+
+    parser.add_argument("-B", "--branch", help="Branch", default="main")
+    parser.add_argument("-N", "--version_name",
+                        help="Version name (Commit name), by default 5 symbols string will be generated.")
+
+    parser.add_argument("--find_existing_entity_by_name", help="Find entities by name", type=bool, default=True)
+    parser.add_argument("--load_attributes", help="Load attributes for entities", type=bool, default=True)
+    parser.add_argument("--load_credentials", help="Load credentials for devices and users", type=bool, default=True)
+    parser.add_argument("--load_relations", help="Load relations for entities", type=bool, default=True)
+    parser.add_argument("--remove_other_entities", help="Remove existing entity", type=bool, default=False)
+
+    args = parser.parse_args()
+    main(**args.__dict__)

tb-rest-client-3.6.3/examples/load_all_entities_from_vcs_pe.py

@@ -0,0 +1,130 @@
+#  Copyright 2024. ThingsBoard
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import logging
+from argparse import ArgumentParser
+from random import choice
+from string import hexdigits
+from time import sleep
+
+from tb_rest_client.models.models_pe import EntityVersion, EntityTypeVersionLoadConfig, EntityTypeVersionLoadRequest
+from tb_rest_client.rest import ApiException
+from tb_rest_client.rest_client_pe import RestClientPE
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(levelname)s - %(module)s - %(lineno)d - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+
+def main(user: str, password: str, host: str = "localhost", port: int = 80, branch: str = "main",
+         auto_generate_integration_key: bool = True, find_existing_entity_by_name: bool = True,
+         load_attributes: bool = True, load_credentials: bool = True, load_relations: bool = True,
+         load_group_entities: bool = True, load_permissions: bool = True, remove_other_entities: bool = False,
+         version_name=None):
+    url = host
+    if "https://" not in host:
+        if "http://" not in host:
+            if port != 443:
+                url = "http://" + host + ":" + str(port)
+            else:
+                url = "https://" + host + ":443"
+
+    with RestClientPE(base_url=url) as rest_client:
+        try:
+            # Auth with credentials
+            logging.info("Logging in...")
+            rest_client.login(username=user, password=password)
+            logging.info("Logged in.")
+
+            if version_name is None:
+                version_name = "".join(choice(hexdigits) for _ in range(5))
+
+            request_config_parameters = {
+                "auto_generate_integration_key": auto_generate_integration_key,
+                "find_existing_entity_by_name": find_existing_entity_by_name,
+                "load_attributes": load_attributes,
+                "load_credentials": load_credentials,
+                "load_relations": load_relations,
+                "load_group_entities": load_group_entities,
+                "load_permissions": load_permissions,
+                "remove_other_entities": remove_other_entities
+            }
+
+            if not [b for b in rest_client.list_branches() if branch in b['name']]:
+                logging.error("Branch not found!")
+                exit(1)
+
+            versions = rest_client.list_versions(branch, 1000, 0)
+            target_versions = [version for version in versions['data'] if version_name in version['name']]
+
+            target_version = target_versions[0]
+            if len(target_versions) > 1:
+                logging.warning(f"\nFound more than one version:\n {target_versions}\n")
+                target_version_index = -1
+                while 0 < target_version_index < len(target_versions):
+                    target_version_index = int(input(f"Please choose the version (1..{len(target_versions)})"))
+                target_version = target_versions[target_version_index - 1]
+
+            logging.info("Restoring to version with name: %r", version_name)
+
+            # Create load version request for previous version
+
+            entities_at_previous_version = rest_client.list_all_entities_at_version(target_version['id'])
+            previous_version_entity_types = set(
+                [entity_obj['externalId']['entityType'] for entity_obj in entities_at_previous_version])
+
+            version_load_request_config = EntityTypeVersionLoadConfig(**request_config_parameters)
+            entity_type_version_load_request_config = {entity_type: version_load_request_config for entity_type in
+                                                       previous_version_entity_types}
+            previous_version_load_request = EntityTypeVersionLoadRequest(entity_type_version_load_request_config,
+                                                                         "ENTITY_TYPE", target_version['id'])
+
+            load_request_id = rest_client.load_entities_version(previous_version_load_request)
+
+            load_request_status = rest_client.get_version_load_request_status(load_request_id)
+            # Wait for restoring and check status
+            while not isinstance(load_request_status, EntityVersion) and not load_request_status.done:
+                load_request_status = rest_client.get_version_load_request_status(load_request_id)
+                sleep(1)
+
+            logging.info("Version load result: %r", load_request_status)
+        except ApiException as e:
+            logging.exception(e)
+
+
+if __name__ == '__main__':
+    parser = ArgumentParser(description="""
+    This script creates new version of all available entities and loads it from version control system.""")
+    parser.add_argument("-U", "--user", help="User email to login into ThingsBoard", required=True)
+    parser.add_argument("-P", "--password", help="User password to login into ThingsBoard", required=True)
+
+    parser.add_argument("-H", "--host", help="ThingsBoard host", default="localhost")
+    parser.add_argument("-p", "--port", help="ThingsBoard port", type=int, default=80)
+
+    parser.add_argument("-B", "--branch", help="Branch", default="main")
+    parser.add_argument("-N", "--version_name",
+                        help="Version name (Commit name), by default 5 symbols string will be generated.")
+
+    parser.add_argument("--auto_generate_integration_key", help="Auto generate key for integrations", type=bool,
+                        default=True)
+    parser.add_argument("--find_existing_entity_by_name", help="Find entities by name", type=bool, default=True)
+    parser.add_argument("--load_attributes", help="Load attributes for entities", type=bool, default=True)
+    parser.add_argument("--load_credentials", help="Load credentials for devices and users", type=bool, default=True)
+    parser.add_argument("--load_relations", help="Load relations for entities", type=bool, default=True)
+    parser.add_argument("--load_group_entities", help="Load entity groups for entities", type=bool, default=True)
+    parser.add_argument("--load_permissions", help="Load permissions for users", type=bool, default=True)
+    parser.add_argument("--remove_other_entities", help="Remove existing entity", type=bool, default=False)
+
+    args = parser.parse_args()
+    main(**args.__dict__)