pyegeria 0.2.4__py3-none-any.whl → 5.3.0.dev3__py3-none-any.whl

pyegeria/commands/ops/list_catalog_targets.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+List catalog targets
+
+"""
+import argparse
+import os
+import time
+
+from rich import box
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.prompt import Prompt
+from rich.table import Table
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    AutomatedCuration,
+    INTEGRATION_GUIDS,
+)
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+
+def display_catalog_targets(
+    connector: str,
+    view_server: str = EGERIA_VIEW_SERVER,
+    view_url: str = EGERIA_VIEW_SERVER_URL,
+    user: str = EGERIA_USER,
+    user_pass: str = EGERIA_USER_PASSWORD,
+    paging: bool = True,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    """Display catalog targets for the specified connector as a table.
+
+    Parameters
+    ----------
+    connector : str
+        The connector to retrieve catalog targets for.
+    view_server : str
+        The Egeria view server name.
+    view_url : str
+        The URL for the Egeria view server.
+    user : str
+        The user name for authenticating with the Egeria server.
+    user_pass : str
+        The user password for authenticating with the Egeria server.
+    paging : bool, default is True
+        Whether to enable paging mode when displaying the table.
+    jupyter : bool
+        Indicates if the environment is a Jupyter notebook.
+    width : int
+        The width of the console for table printing.
+    """
+    console = Console(force_terminal=not jupyter, width=width, soft_wrap=True)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"All Catalog Targets for Integration Connector {connector} @ {time.asctime()}",
+            style="bold white on black",
+            row_styles=["bold white on black"],
+            header_style="white on dark_blue",
+            title_style="bold white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Catalog Targets for '{view_server}' @ Platform - {view_url}",
+            expand=True,
+        )
+        table.add_column("Name of Target")
+        table.add_column("Catalog Target")
+
+        # table.add_column("Relationship GUID", no_wrap=True)
+        table.add_column("Configuration Properties")
+        table.add_column("Template Properties")
+        table.add_column("Operational Instructions", max_width=20)
+        # table.add_column("Delete Method")
+
+        if type(cat_targets) is list:
+            for target in cat_targets:
+                target_name = target.get("catalogTargetName", "---")
+                target_source = target.get("metadataSourceQualifiedName", "---")
+                target_rel = target.get("relationshipGUID", "---")
+                target_sync = target.get("permittedSynchronization")
+                target_delete = target.get("deleteMethod", "---")
+                op_instruct = f"* {target_sync}\n* {target_delete}"
+                op_instruct_out = Markdown(op_instruct)
+                # target_guid = target['catalogTargetElement']['guid']
+                connector_unique = target["catalogTargetElement"]["uniqueName"]
+
+                cat_target_out = Markdown(
+                    f"* Target Name: {target_name}\n* Target Source: {target_source}\n"
+                    f"* Relationship Guid: {target_rel}"
+                )
+
+                config_props = target.get("configurationProperties", "---")
+                if type(config_props) is dict:
+                    config_props_md = ""
+                    for prop in config_props:
+                        config_props_md += f"* {prop}: {config_props[prop]}\n"
+                    config_props_out = Markdown(config_props_md)
+                else:
+                    config_props_out = "---"
+
+                template_props = target.get("templateProperties", "---")
+                if type(template_props) is dict:
+                    template_props_md = ""
+                    for prop in template_props:
+                        template_props_md += f"* {prop}: {template_props[prop]}\n"
+                    template_props_out = Markdown(template_props_md)
+                else:
+                    template_props_out = "---"
+
+                table.add_row(
+                    connector_unique,
+                    cat_target_out,
+                    config_props_out,
+                    template_props_out,
+                    op_instruct_out,
+                )
+
+        return table
+
+    try:
+        a_client = AutomatedCuration(view_server, view_url, user)
+        token = a_client.create_egeria_bearer_token(user, user_pass)
+        connector = connector.strip()
+        if connector not in INTEGRATION_GUIDS.keys():
+            raise Exception
+
+        connector_guid = INTEGRATION_GUIDS[connector]
+        cat_targets = a_client.get_catalog_targets(connector_guid)
+        console = Console(force_terminal=not jupyter, width=width, soft_wrap=True)
+        with console.pager(styles=True):
+            console.print(generate_table(), soft_wrap=True)
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+    except Exception as e:
+        print(f"\n\n===> Perhaps integration connector {connector} is not known?\n\n")
+        console.print_exception()
+    finally:
+        a_client.close_session()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+    parser.add_argument("--jupyter", help="Enable for Jupyter terminal compatibility")
+    parser.add_argument("--width", help="Screen width, in characters, to use")
+
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_VIEW_SERVER
+    url = args.url if args.url is not None else EGERIA_VIEW_SERVER_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    jupyter = args.jupyter if args.jupyter is not None else EGERIA_JUPYTER
+    width = args.width if args.width is not None else EGERIA_WIDTH
+
+    try:
+        connector = Prompt.ask(
+            "Enter the Integration Connector to list catalog targets for"
+        ).strip()
+        display_catalog_targets(
+            connector, server, url, userid, user_pass, jupyter, width=width
+        )
+
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/ops/load_archive.py

@@ -0,0 +1,75 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+This script refreshed an integration daemon.
+
+"""
+
+import os
+import click
+from pyegeria import AutomatedCuration, EgeriaTech
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON_URL = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443"
+)
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+
+
+@click.command("load-archive")
+@click.option(
+    "--file_name",
+    default="content-packs/CocoComboArchive.omarchive",
+    help="Full path on the Metadata Server to the archive file to load",
+)
+@click.option(
+    "--server_name", default=EGERIA_METADATA_STORE, help="Egeria metadata store to load"
+)
+@click.option(
+    "--view-server", default=EGERIA_VIEW_SERVER, help="Egeria view server to connect to"
+)
+@click.option(
+    "--url", default=EGERIA_PLATFORM_URL, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_USER, help="Egeria admin user")
+@click.option("--password", default=EGERIA_USER_PASSWORD, help="Egeria admin password")
+@click.option("--timeout", default=120, help="Number of seconds to wait")
+def load_archive(file_name, server_name, view_server, url, userid, password, timeout):
+    """Load an Open Metadata Archive"""
+
+    try:
+        s_client = EgeriaTech(view_server, url, userid, password)
+        token = s_client.create_egeria_bearer_token()
+        server_guid = None
+        file_name = file_name.strip()
+        s_client.add_archive_file(file_name, server_guid, server_name, time_out=timeout)
+
+        click.echo(f"Loaded archive: {file_name}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print(
+            f"Perhaps there was a timeout? If so, the command will complete despite the exception\n"
+            f"===> You can check by rerunning the command in a few minutes"
+        )
+        print_exception_response(e)
+
+
+if __name__ == "__main__":
+    load_archive()

pyegeria/commands/ops/monitor_asset_events.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Display the status of cataloged platforms and servers.
+"""
+import json
+import os
+import time
+import argparse
+from datetime import datetime
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.live import Live
+from rich.console import Console
+from rich.markdown import Markdown
+from confluent_kafka import Consumer, KafkaException
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9192")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = os.environ.get("EGERIA_JUPYTER", False)
+EGERIA_WIDTH = os.environ.get("EGERIA_WIDTH", 200)
+
+
+def main(ep: str = EGERIA_KAFKA_ENDPOINT):
+    disable_ssl_warnings = True
+    console = Console(width=200)
+    now = datetime.now()
+    current_time = now.strftime("%H:%M:%S")
+
+    earliest_latest = Prompt.ask("Msgs from earliest or latest:", default="earliest")
+
+    # Define the Kafka consumer configuration.
+    config = {
+        "bootstrap.servers": ep,  # replace with your Kafka broker(s)
+        "group.id": f"view_asset_events:{current_time}",  # replace with your consumer group
+        "auto.offset.reset": earliest_latest,  # can be set to 'earliest' or 'latest'
+    }
+    print(f"Kafka config is {json.dumps(config)}")
+    # Initialize a Kafka consumer.
+    consumer = Consumer(config)
+
+    # Subscribe to a Kafka topic.
+    consumer.subscribe(
+        ["egeria.omag.server.active-metadata-store.omas.assetconsumer.outTopic"]
+    )  # replace with your Kafka topic
+
+    try:
+        while True:
+            msg = consumer.poll(2.0)  # timeout set to 1 second
+
+            if msg is None:
+                continue
+            elif msg.error():
+                raise KafkaException(msg.error())
+            else:
+                event = json.loads(msg.value())
+                event_time = event["eventTime"]
+                event_type = event["eventType"]
+                guid = event["elementHeader"]["guid"]
+
+                type_name = event["elementHeader"]["type"]["typeName"]
+                origin = event["elementHeader"]["origin"]["sourceServer"]
+
+                element_properties = event["elementProperties"]
+                element_properties_keys = element_properties.keys()
+                props = " "
+                for key in element_properties_keys:
+                    value = element_properties[key]
+                    props += f"* {key}: {value}\n"
+                console.rule(style="[bold red]")
+                console.rule(
+                    f"\tMessage TimeStamp: {event_time}\t eventType: {event_type}\t typeName: {type_name}\t guid: {guid}"
+                )
+                msg = f"properties: \n[bright white on black]{props}\n\n"
+                msg = Markdown(msg)
+
+                console.print(msg)
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        # Close down consumer to commit final offsets.
+        consumer.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--ep", help="Endpoint to connect to")
+    args = parser.parse_args()
+
+    ep = args.ep if args.ep is not None else EGERIA_KAFKA_ENDPOINT
+
+    main(ep)

pyegeria/commands/ops/monitor_engine_activity.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple status display for Engine Actions
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+
+from pyegeria import AutomatedCuration
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_ENGINE_HOST = os.environ.get("INTEGRATION_ENGINE_HOST", "engine-host")
+EGERIA_ENGINE_HOST_URL = os.environ.get(
+    "INTEGRATION_ENGINE_HOST_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+disable_ssl_warnings = True
+
+
+def display_engine_activity(
+    row_limit: int = 0,
+    view_server: str = EGERIA_VIEW_SERVER,
+    view_url: str = EGERIA_VIEW_SERVER_URL,
+    user: str = EGERIA_USER,
+    user_pass: str = EGERIA_USER_PASSWORD,
+    paging: bool = True,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    """Display governance engine activity as a table.
+
+    Parameters
+    ----------
+    row_limit : int, opt, default = 0
+        If non-zero, limit the number of rows returned
+    view_server : str
+        The Egeria view server name.
+    view_url : str
+        The URL for the Egeria view server.
+    user : str
+        The user name for authenticating with the Egeria server.
+    user_pass : str
+        The user password for authenticating with the Egeria server.
+    paging : bool, default is True
+        Whether to enable paging mode when displaying the table.
+    jupyter : bool
+        Indicates if the environment is a Jupyter notebook.
+    width : int
+        The width of the console for table printing.
+    """
+    g_client = AutomatedCuration(view_server, view_url, user, user_pwd=user_pass)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Engine Action Status for Platform {view_url} @ {time.asctime()}",
+            style="bold white on black",
+            row_styles=["bold white on black"],
+            header_style="white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Engine Status for Server '{view_server}' @ Platform - {view_url}",
+            expand=True,
+        )
+        table.add_column("Requested Time")
+        table.add_column("Start Time")
+        table.add_column("Action GUID", no_wrap=True)
+        table.add_column("Engine Name")
+        table.add_column("Request Type")
+        table.add_column("Action Status")
+        table.add_column("Target Element")
+        table.add_column("Completion Time")
+        table.add_column("Process Name")
+        table.add_column("Completion Message")
+
+        token = g_client.create_egeria_bearer_token()
+        action_status = g_client.get_engine_actions()
+
+        if type(action_status) is str:
+            requested_time = " "
+            start_time = " "
+            completion_time = " "
+            engine_name = " "
+            request_type = " "
+            action_status = " "
+            target_element = " "
+            process_name = " "
+            completion_message = " "
+        elif type(action_status) is list:
+            sorted_action_status = sorted(
+                action_status,
+                key=lambda i: i.get("requestedTime", time.asctime()),
+                reverse=True,
+            )
+            row_count = 0
+            for action in sorted_action_status:
+                if row_limit > 0 and row_count >= row_limit:
+                    break
+                row_count += 1
+                requested_time = action.get("requestedTime", " ")
+                start_time = action.get("startTime", " ")
+                completion_time = action.get("completionTime", " ")
+
+                engine_name = action["governanceEngineName"]
+                request_type = action["requestType"]
+                action_guid = action["elementHeader"]["guid"]
+                if action["actionStatus"] in (
+                    "REQUESTED",
+                    "APPROVED",
+                    "WAITING",
+                    "ACTIVATING",
+                ):
+                    action_status = f"[yellow]{action['actionStatus']}"
+                elif action["actionStatus"] in ("IN_PROGRESS", "ACTIONED"):
+                    action_status = f"[green]{action['actionStatus']}"
+                else:
+                    action_status = f"[red]{action['actionStatus']}"
+
+                targets = action.get("actionTargetElements", "Empty")
+                if type(targets) is list:
+                    tgt_tab = Table()
+                    tgt_tab.add_column("name")
+                    tgt_tab.add_column("guid", no_wrap=True)
+                    tgt_tab.add_column("type_name")
+                    targets_md = ""
+                    for target in targets:
+                        t_name = target["actionTargetName"]
+                        t_guid = target["actionTargetGUID"]
+                        t_type = target["targetElement"]["type"]["typeName"]
+                        tgt_tab.add_row(t_name, t_guid, t_type)
+                    # target_element = json.dumps(target[0]["targetElement"]["elementProperties"]["propertiesAsStrings"])
+                    target_element = tgt_tab
+                else:
+                    target_element = " "
+
+                process_name = action.get("processName", " ")
+                completion_message = action.get("completionMessage", " ")
+
+                table.add_row(
+                    requested_time,
+                    start_time,
+                    action_guid,
+                    engine_name,
+                    request_type,
+                    action_status,
+                    target_element,
+                    completion_time,
+                    process_name,
+                    completion_message,
+                )
+        else:
+            print("Egeria integration daemon not running")
+            sys.exit()
+
+        return table
+
+    try:
+        if paging is True:
+            console = Console(width=width, force_terminal=not jupyter)
+            with console.pager():
+                console.print(generate_table())
+        else:
+            with Live(
+                generate_table(),
+                refresh_per_second=1,
+                screen=True,
+                vertical_overflow="visible",
+            ) as live:
+                while True:
+                    time.sleep(2)
+                    live.update(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        g_client.close_session()
+
+
+def main_live():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--rowlimit", default=0, help="Number of rows to return; 0 for all"
+    )
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_VIEW_SERVER
+    url = args.url if args.url is not None else EGERIA_VIEW_SERVER_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    rowlimit = int(args.rowlimit) if args.rowlimit is not None else 0
+
+    display_engine_activity(
+        rowlimit, server, url, user=userid, user_pass=user_pass, paging=False
+    )
+
+
+def main_paging():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--rowlimit", default=0, help="Number of rows to return; 0 for all"
+    )
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_VIEW_SERVER
+    url = args.url if args.url is not None else EGERIA_VIEW_SERVER_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    rowlimit = int(args.rowlimit) if args.rowlimit is not None else 0
+
+    display_engine_activity(
+        rowlimit, server, url, user=userid, user_pass=user_pass, paging=True
+    )
+
+
+if __name__ == "__main__":
+    main_live()
+
+if __name__ == "__main_paging__":
+    main_paging()