perspective-cli 0.1.0__py3-none-any.whl

perspective/ingest/sources/bi/qlik_sense/extract.py

@@ -0,0 +1,297 @@
+"""Playground for Qlik Sense APIs exploration.
+
+We connect to two APIs:
+- Qlik Sense Repository Service (QRS) API
+- Qlik Engine JSON API
+
+We connect using the default Virtual Proxy Service (built into Qlik Sense Enterprise
+default configuration, so no server-side configuration is required).
+
+For auth, for the time being we use the Windows login method (NTLM), combined with the
+"header" method of authenticating to these APIs.
+
+In the case of the QRS API, we use the requests library to make HTTP requests, and use
+the requests_ntlm library to handle NTLM authentication.
+
+For the Qlik Engine JSON API, we use the websocket library to create a WebSocket
+connection. To authenticate, we use a Qlik session ID that we get from calling a
+QRS API endpoint (the endpoint doesn't matter, we only care that the server returns
+a session ID in its response) using the method described above.
+"""
+
+from collections.abc import Generator
+import json
+from pathlib import Path
+import secrets
+import ssl
+import string
+from typing import Any
+
+import dlt
+from dlt.extract.resource import DltResource
+from loguru import logger
+import requests
+from requests_ntlm import HttpNtlmAuth
+import websocket
+
+
+# # Disable SSL warnings (optional but recommended for self-signed certs)
+requests.packages.urllib3.disable_warnings()
+
+
+def get_qrs_session(ntlm_username: str, ntlm_password: str) -> requests.Session:
+    """Create and configure a requests Session for QRS API."""
+    session = requests.Session()
+    # Probably a typo of xsrf; anyway, this is a random string of 16 alphanumeric chars.
+    alphabet = string.ascii_uppercase + string.ascii_lowercase + string.digits
+    xrfkey = "".join(secrets.choice(alphabet) for _ in range(16))
+    headers = {
+        "x-qlik-xrfkey": xrfkey,
+        "User-Agent": "Windows",
+    }
+    session.auth = HttpNtlmAuth(ntlm_username, ntlm_password)
+    session.headers = headers
+    session.params = {"xrfkey": xrfkey}
+    session.verify = False
+    return session
+
+
+def get_qlik_session_id(
+    qrs_api_base_url: str, ntlm_username: str, ntlm_password: str
+) -> str:
+    """Retrieve Qlik session ID from the QRS API.
+
+    Raises:
+        ValueError: If session ID could not be retrieved.
+
+    Returns:
+        str: The Qlik session ID.
+    """
+    session = get_qrs_session(ntlm_username=ntlm_username, ntlm_password=ntlm_password)
+
+    logger.debug("Retrieving Qlik session ID...")
+
+    full_url = qrs_api_base_url + "/about"
+    response = session.get(full_url)
+    response.raise_for_status()
+    session_id = session.cookies.get("X-Qlik-Session")
+
+    if not session_id:
+        msg = "Could not retrieve Qlik session ID. Perhaps Qlik API's logic changed?"
+        raise ValueError(msg)
+
+    logger.debug(f"Retrieved Qlik session ID: {session_id}.")
+    return session_id
+
+
+def get_socket(engine_api_url: str, session_id: str) -> websocket.WebSocket:
+    """Create a WebSocket connection to the Qlik Engine JSON API.
+
+    Args:
+        engine_api_url (str): The URL of the Qlik Engine JSON API.
+        session_id (str): The ID of the Qlik session to use.
+
+    Returns:
+        websocket.WebSocket: An authenticated socket connection.
+    """
+    # Get a Qlik session ID from QRS API.
+    # This way, we can (indirectly) use header auth in the Qlik Engine JSON API.
+    headers = {"Cookie": f"X-Qlik-Session={session_id}"}
+
+    # Connect to the Qlik Engine JSON API.
+    logger.info("Creating a socket...")
+
+    socket = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
+    socket.connect(engine_api_url, header=headers)
+    on_authentication_msg = json.loads(socket.recv())
+    logger.debug("On authentication message: ", on_authentication_msg)
+    if on_authentication_msg["params"]["mustAuthenticate"]:
+        msg = "Could not authenticate to Qlik Engine JSON API."
+        msg += " Please ensure you're authenticated and provide a valid session ID."
+        raise ValueError(msg)
+
+    on_connected_msg = socket.recv()
+    logger.debug("On connected message: ", on_connected_msg)
+
+    return socket
+
+
+def get(
+    request: dict[str, Any],
+    engine_api_url: str,
+    session_id: str | None = None,
+    socket: websocket.WebSocket | None = None,
+) -> dict[str, Any]:
+    """Retrieve a response from the Qlik Engine JSON API using WebSocket.
+
+    Args:
+        request (dict[str, Any]): The request body.
+        engine_api_url (str): The URL of the Qlik Engine JSON API.
+        session_id (str | None, optional): The ID of the Qlik session to use. Defaults
+            to None.
+        socket (websocket.WebSocket | None, optional): The socket to use. Defaults to
+            None.
+
+    Raises:
+        ValueError: If neither a session nor a socket is provided, or if the socket is
+            specified, but without its session.
+
+    Returns:
+        dict[str, Any] | None: The response from Qlik Engine JSON API.
+    """
+    if not session_id and not socket:
+        msg = "Either `socket` or `session_id` must be provided."
+        raise ValueError(msg)
+
+    is_socket_externally_managed = bool(socket)
+    if not is_socket_externally_managed:
+        socket = get_socket(engine_api_url, session_id=session_id)
+
+    logger.info(f"Calling '{request['method']}' method...")
+    socket.send(json.dumps(request))
+    response = json.loads(socket.recv())
+
+    if not is_socket_externally_managed:
+        socket.close()
+
+    if machine_readable_error := response.get("error"):
+        error_code = machine_readable_error["code"]
+        error_message_short = machine_readable_error["message"]
+        error_message_long = machine_readable_error["parameter"]
+        human_readable_error = (
+            f"Error {error_code} ('{error_message_short}'). " + error_message_long + "."
+        )
+        raise ValueError(human_readable_error)
+
+    return response["result"]
+
+
+@dlt.source
+def qlik_sense(
+    qrs_api_base_url: str = dlt.secrets.value,
+    engine_api_url: str = dlt.secrets.value,
+    ntlm_username: str = dlt.secrets.value,
+    ntlm_password: str = dlt.secrets.value,
+) -> list[DltResource]:
+    """The Qlik Sense metadata source."""
+    # We use a single Qlik session for all requests.
+    qlik_session_id = get_qlik_session_id(
+        qrs_api_base_url, ntlm_username=ntlm_username, ntlm_password=ntlm_password
+    )
+
+    @dlt.resource(primary_key="qDocId", write_disposition="merge")
+    def apps_engine(
+        modified_at: dlt.sources.incremental = dlt.sources.incremental(  # noqa: B008
+            "modifiedDate", initial_value="2024-01-01T00:00:00Z"
+        ),
+    ) -> DltResource:
+        """Get metadata about all apps in Qlik Sense from the Engine JSON API."""
+        query = {
+            "jsonrpc": "2.0",
+            # "id": 1,
+            "method": "GetDocList",
+            "handle": -1,
+            "params": [],
+        }
+        apps_info_nested = get(
+            query, session_id=qlik_session_id, engine_api_url=engine_api_url
+        )
+        # Unnest and return only the modified apps.
+        yield from [
+            {
+                "qDocId": app["qDocId"],
+                "qDocName": app["qDocName"],
+                "description": app["qMeta"]["description"],
+                "createdDate": app["qMeta"]["createdDate"],
+                "modifiedDate": app["qMeta"]["modifiedDate"],
+                "stream": {
+                    "id": app["qMeta"]["stream"]["id"]
+                    if app["qMeta"].get("stream")
+                    else None,
+                    "name": app["qMeta"]["stream"]["name"]
+                    if app["qMeta"].get("stream")
+                    else None,
+                },
+            }
+            for app in apps_info_nested["qDocList"]
+            if app["qMeta"]["modifiedDate"] > modified_at.start_value
+        ]
+
+    @dlt.transformer(data_from=apps_engine, primary_key="id", write_disposition="merge")
+    def app_details_qrs(app: dict[str, Any]) -> Generator[dict[str, Any], None, None]:
+        app_id = app["qDocId"]
+
+        logger.debug(f"Retrieving app {app_id} details from QRS API...")
+
+        session = get_qrs_session(
+            ntlm_username=ntlm_username, ntlm_password=ntlm_password
+        )
+        full_url = qrs_api_base_url + f"/app/{app_id}"
+        response = session.get(full_url)
+        response.raise_for_status()
+        yield response.json()
+
+    @dlt.transformer(data_from=apps_engine, primary_key="id", write_disposition="merge")
+    def app_details_engine(
+        app: dict[str, Any],
+    ) -> Generator[dict[str, Any], None, None]:
+        app_id = app["qDocId"]
+        # These two requests are connected, so we need to perform them on the same
+        # socket.
+        socket = get_socket(engine_api_url, session_id=qlik_session_id)
+        open_app_query = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "OpenDoc",
+            "handle": -1,
+            "params": {"qDocName": app_id},
+        }
+        lineage_query = {
+            "jsonrpc": "2.0",
+            "id": 2,
+            "method": "GetLineage",
+            "handle": 1,
+            "params": {},
+        }
+
+        logger.debug(f"Retrieving app {app_id} details from Qlik Engine JSON API...")
+
+        try:
+            _ = get(open_app_query, socket=socket, engine_api_url=engine_api_url)
+            lineage = get(lineage_query, socket=socket, engine_api_url=engine_api_url)[
+                "qLineage"
+            ]
+        except Exception as e:
+            msg = (
+                f"Failed retrieving lineage for app: {app['qDocName']} (ID: {app_id})."
+            )
+            logger.exception(e, msg=msg)
+        finally:
+            socket.close()
+
+        # NOTE: We enrich the response with the app ID so that it can be handled
+        # properly.
+        yield {"id": app_id, "lineage": lineage}
+
+    return [apps_engine, app_details_qrs, app_details_engine]
+
+
+if __name__ == "__main__":
+    # source = qlik_sense().add_limit(2)
+    from loguru import logger
+
+    source = qlik_sense()
+    # for apps_engine, app_details_qrs, app_details_engine in source:
+    #     print(json.dumps(app_details_qrs, indent=4))
+    #     print("-" * 30)
+    #     print(json.dumps(app_details_engine, indent=4))
+    app_details_qrs = list(source.with_resources("app_details_qrs"))
+    app_details_engine = list(source.with_resources("app_details_engine"))
+    logger.info(f"{len(app_details_qrs)} apps in QRS API.")
+    logger.info(f"{len(app_details_engine)} apps in Engine JSON API.")
+
+    with Path("app_details_qrs.json").open("w", encoding="utf-8") as f:
+        json.dump(app_details_qrs, f, indent=4)
+
+    with Path("app_details_engine.json").open("w", encoding="utf-8") as f:
+        json.dump(app_details_engine, f, indent=4)

perspective/ingest/sources/bi/qlik_sense/models.py

@@ -0,0 +1,22 @@
+"""Pydantic models for Qlik Sense APIs responses."""
+
+from pydantic import BaseModel, EmailStr
+
+
+class AppDetailsQRS(BaseModel):
+    id: str
+    name: str
+    description: str | None
+    owner: EmailStr | None
+    created_at: str
+    updated_at: str
+
+
+class Table(BaseModel):
+    qDiscriminator: str
+    qStatement: str | None = None
+
+
+class AppDetailsEngine(BaseModel):
+    app_id: str
+    lineage: list[Table]

perspective/ingest/sources/bi/qlik_sense/pipeline.py

@@ -0,0 +1,19 @@
+"""dlt pipeline to load Qlik Sense metadata into DuckDB."""
+
+import dlt
+
+from perspective.ingest.sources.bi.qlik_sense.extract import qlik_sense
+
+
+pipe = dlt.pipeline(
+    pipeline_name="qlik_to_duckdb",
+    destination=dlt.destinations.duckdb("db.duckdb"),
+    dataset_name="qlik_sense",
+)
+
+if __name__ == "__main__":
+    from loguru import logger
+
+    # load_package = pipe.run(qlik().add_limit(5), refresh="drop_data") # For testing.
+    load_package = pipe.run(qlik_sense().add_limit(5))
+    logger.info(load_package)

perspective/ingest/sources/bi/qlik_sense/transform.py

@@ -0,0 +1,76 @@
+"""Transform Qlik Sense metadata into Perspective DashboardManifest format."""
+
+import json
+from pathlib import Path
+
+from perspective.ingest.sources.bi.qlik_sense.models import (
+    AppDetailsEngine,
+    AppDetailsQRS,
+)
+from perspective.models.dashboards import (
+    Dashboard,
+    DashboardManifest,
+    DashboardSchemaMetadata,
+    DataModel,
+)
+
+
+def transform(
+    app_details_qrs: AppDetailsQRS, app_details_engine: AppDetailsEngine
+) -> DashboardManifest:
+    # Extract tables from the Qlik Sense metadata.
+    # tables = extract_tables(workspace_info)
+    # reports = extract_reports(workspace_info, tables=tables)
+
+    # return DashboardManifest(
+    #     metadata=DashboardSchemaMetadata(schema="dashboard", version=1),
+    #     payload=reports,
+    # )
+    """Join app metadata from the two sources: QRS API and Engine JSON API.
+
+    Args:
+        app_details_qrs (list[AppDetailsQRS]): List of app details from QRS API.
+        app_details_engine (list[AppDetailsEngine]): List of app details from Engine
+            JSON API.
+    """
+    apps = []
+    for app in app_details_qrs:
+        app_parsed = {
+            "external_id": app["id"],
+            "url": f"{app['resourceId']}/hub/{app['id']}",
+            "type": "qliksense",
+            "name": app["name"],
+            "workspace": app.get("stream", {}).get("name", "My Work"),
+            "created_at": app.get("createdDate"),
+            "modified_at": app.get("modifiedDate"),
+            "owners": [
+                {
+                    "user_id": app.get("owner", {}).get("userId", ""),
+                    "username": app.get("owner", {}).get("userDirectory", ""),
+                    "name": app.get("owner", {}).get("name", ""),
+                }
+            ],
+            "parent_models": [],
+        }
+
+        apps.append(app_parsed)
+
+    return DashboardManifest(
+        metadata=DashboardSchemaMetadata(schema="dashboard", version=1),
+        payload=apps,
+    )
+
+
+if __name__ == "__main__":
+    from loguru import logger
+
+    with Path("app_details_qrs.json").open(encoding="utf-8") as f:
+        app_details_qrs = json.load(f)
+
+    with Path("app_details_engine.json").open(encoding="utf-8") as f:
+        app_details_engine = json.load(f)
+
+    dashboard_manifest = transform(
+        app_details_qrs=app_details_qrs, app_details_engine=app_details_engine
+    )
+    logger.info(dashboard_manifest)

perspective/ingest/sources/database/sap/extract.py

@@ -0,0 +1,253 @@
+import dlt
+
+
+try:
+    import pyrfc
+    from pyrfc._exception import (
+        ABAPApplicationError,
+        ABAPRuntimeError,
+        CommunicationError,
+    )
+except ModuleNotFoundError as e:
+    msg = "The 'pyrfc' package is required to use the SAPRFC source. "
+    raise ImportError(msg) from e
+from itertools import batched
+import string
+import textwrap
+
+from loguru import logger
+
+
+@dlt.source(name="sap")
+def sap(
+    ashost: str = dlt.secrets.value,
+    sysnr: str = dlt.secrets.value,
+    username: str = dlt.secrets.value,
+    passwd: str = dlt.secrets.value,
+):
+    """Query SAP with SQL using the RFC protocol.
+
+    Use the RFC_READ_TABLE to read SAP table metadata.
+    """
+    delimiter = "\t"
+
+    # Test the connection.
+    con = pyrfc.Connection(
+        ashost=ashost,
+        sysnr=sysnr,
+        user=username,
+        passwd=passwd,
+    )
+    logger.info("Checking the connection...")
+    try:
+        con.ping()
+        logger.info("Connection successful.")
+    except Exception as e:
+        logger.exception("Connection to SAP failed.")
+        raise
+    finally:
+        con.close()
+
+    # By convention, custom tables use a "Z" or "Y" prefix in their name.
+    custom_table_prefixes = ["Z", "Y"]
+    standard_table_prefixes = [
+        char for char in string.ascii_uppercase if char not in custom_table_prefixes
+    ]
+
+    def get_response(
+        params,
+        func: str = "RFC_READ_TABLE",
+        data_key: str = "DATA",
+        fallback_data_key: str | None = None,
+        record_key: str = "WA",
+        fallback_record_key: str | None = None,
+    ):
+        """Call the RFC function with the given parameters."""
+        con = pyrfc.Connection(
+            ashost=ashost,
+            sysnr=sysnr,
+            user=username,
+            passwd=passwd,
+        )
+        try:
+            response = con.call(func, **params)
+        except (ABAPApplicationError, ABAPRuntimeError, CommunicationError) as e:
+            if e.key == "DATA_BUFFER_EXCEEDED":
+                msg = "Character limit per row exceeded. Please select fewer columns."
+            elif e.key == "TSV_TNEW_PAGE_ALLOC_FAILED":
+                msg = "Memory allocation failed; try a smaller batch size."
+            else:
+                msg = f"Error while calling {func} with params:\n{params}."
+            logger.exception(msg)
+            raise
+        finally:
+            con.close()
+
+        # Process the response into records.
+        data_raw = response.get(data_key) or response.get(fallback_data_key)
+        data = [
+            [
+                value.strip()
+                for value in row.get(record_key, row.get(fallback_record_key)).split(
+                    delimiter
+                )
+            ]
+            for row in data_raw
+        ]
+        logger.info(f"Retrieved {len(data)} rows.")
+        columns = params.get("FIELDS")
+        if columns:
+            return [dict(zip(columns, row)) for row in data]
+        return data
+
+    def get_table_schema(table_prefixes: list[str]):
+        conditions = [f"TABNAME LIKE '{prefix}%'" for prefix in table_prefixes]
+        # Each line in OPTIONS must be ≤72 characters.
+        grouped = textwrap.wrap(" OR ".join(conditions), width=72)
+        options = [{"TEXT": line} for line in grouped]
+        # Filter out internal SAP objects.
+        options += [{"TEXT": " AND TABCLASS = 'TRANSP'"}]
+        params = {
+            "QUERY_TABLE": "DD02L",
+            "FIELDS": ["TABNAME"],
+            "OPTIONS": options,
+            "DELIMITER": delimiter,
+        }
+        yield get_response(params)
+
+    @dlt.resource(
+        name="standard_tables", write_disposition="merge", primary_key="TABNAME"
+    )
+    def standard_tables():
+        """Get a list of standard SAP tables."""
+        yield get_table_schema(standard_table_prefixes)
+
+    @dlt.resource(write_disposition="merge", primary_key="TABNAME")
+    def custom_tables():
+        """Get a list of custom SAP tables."""
+        yield get_table_schema(custom_table_prefixes)
+
+    def get_table_details(table_names):
+        """Get metadata about SAP tables."""
+        table_batches = batched(table_names, 1000)
+        for batch_number, batch in enumerate(table_batches, start=1):
+            conditions = [f"TABNAME = '{table}'" for table in batch]
+            # Each line in OPTIONS must be ≤72 characters.
+            grouped = textwrap.wrap(" OR ".join(conditions), width=72)
+            options = [{"TEXT": line} for line in grouped]
+            params = {
+                "QUERY_TABLE": "DD03L",
+                "FIELDS": ["TABNAME", "FIELDNAME", "DATATYPE", "LENG"],
+                "OPTIONS": options,
+                "DELIMITER": delimiter,
+            }
+            logger.info(f"Extracting table batch number {batch_number}...")
+            yield get_response(params)
+
+    @dlt.transformer(
+        data_from=standard_tables,
+        write_disposition="merge",
+        primary_key=("TABNAME", "FIELDNAME"),
+    )
+    def standard_tables_details(standard_tables):
+        standard_table_names = [row["TABNAME"] for row in standard_tables]
+        yield get_table_details(standard_table_names)
+
+    @dlt.transformer(
+        data_from=custom_tables,
+        write_disposition="merge",
+        primary_key=("TABNAME", "FIELDNAME"),
+    )
+    def custom_tables_details(custom_tables):
+        custom_table_names = [row["TABNAME"] for row in custom_tables]
+        yield get_table_details(custom_table_names)
+
+    @dlt.resource(write_disposition="merge", primary_key="ROLLNAME")
+    def column_details():
+        """Get metadata about table columns in SAP tables."""
+        params = {
+            "QUERY_TABLE": "DD04T",
+            "FIELDS": ["ROLLNAME", "DDTEXT"],
+            "OPTIONS": [{"TEXT": "DDLANGUAGE = 'EN'"}],
+            "DELIMITER": delimiter,
+        }
+        logger.info("Extracting table columns...")
+        yield get_response(params)
+
+    @dlt.resource(write_disposition="replace")
+    def abap_programs():
+        """List all ABAP programs (reports, includes, module pools, etc.)."""
+        # Iterate 5 letters at a time as SAP can't handle large queries,
+        # and it seems there can be millions of ABAP programs.
+        logger.info("Extracting ABAP programs...")
+        for prefixes_group in batched(string.ascii_uppercase, 5):
+            logger.info(
+                f"Extracting programs with the following prefixes: {prefixes_group}..."
+            )
+            conditions = [f"NAME LIKE '{prefix}%'" for prefix in prefixes_group]
+
+            # Each line in OPTIONS must be ≤72 characters.
+            grouped = textwrap.wrap(" OR ".join(conditions), width=72)
+            options = [{"TEXT": line} for line in grouped]
+            # '1' = Executable report
+            # 'I' = Include
+            # 'M' = Module pool (dialog program)
+            # 'F' = Function group main program (needed for function modules)
+            # 'K' = Class pool (needed for global classes)
+            # 'J' = Interface pool
+            # 'S' = Subroutine pool
+            options += [{"TEXT": " AND SUBC IN ('1','I','M','F','K','J','S')"}]
+            # NOTE: all these filters only remove ~5% of records.
+            params = {
+                "QUERY_TABLE": "TRDIR",
+                "FIELDS": ["NAME"],
+                "OPTIONS": options,
+                "DELIMITER": delimiter,
+            }
+            yield get_response(params)
+
+    @dlt.transformer(
+        data_from=abap_programs, write_disposition="merge", primary_key="name"
+    )
+    def abap_programs_source_code(abap_programs):
+        logger.info("Extracting the source code of ABAP programs...")
+        program_names = (row["NAME"] for row in abap_programs)
+        for program in program_names:
+            params = {"PROGRAM_NAME": program}
+            logger.info(f"Extracting source for ABAP program: {program}...")
+            source_code_lines = get_response(
+                params,
+                func="RPY_PROGRAM_READ",
+                data_key="SOURCE",
+                fallback_data_key="SOURCE_EXTENDED",
+                fallback_record_key="LINE",
+            )
+            yield {
+                "name": program,
+                "source": "\n".join([line[0] for line in source_code_lines]),
+            }
+
+    @dlt.resource(write_disposition="replace")
+    def abap_transactions():
+        pass
+
+    return [
+        standard_tables,
+        standard_tables_details,
+        custom_tables,
+        custom_tables_details,
+        column_details,
+        abap_programs,
+        abap_programs_source_code,
+    ]
+
+
+if __name__ == "__main__":
+    pipeline = dlt.pipeline(
+        pipeline_name="sap", destination="duckdb", dataset_name="bronze"
+    )
+    # pipeline.run(sap.with_resources("column_details", "custom_tables_details"))
+    # pipeline.run(sap().with_resources("column_details", "standard_tables_details"))
+    pipeline.run(sap().with_resources("abap_programs_source_code"))
+    # pipeline.run(sap().add_limit(1).with_resources("abap_programs"))
+    # pipeline.run(sap().with_resources("abap_programs"))

perspective/ingest/sources/database/sap/pipeline.py

@@ -0,0 +1,23 @@
+from typing import Generator
+
+from loguru import logger
+
+from lumaCLI.metadata.models.database import DatabaseTableManifest
+from lumaCLI.metadata.sources.sap.extract import sap
+from lumaCLI.metadata.sources.sap.transform import transform
+
+
+def pipeline() -> Generator[DatabaseTableManifest, None, None]:
+    """Pipeline to extract SAP metadata and."""
+    source = sap().with_resources("column_details", "custom_tables_details")
+    manifest_batches = transform()
+    yield from manifest_batches
+
+
+if __name__ == "__main__":
+    manifest_batches = pipeline()
+    for i, manifest in enumerate(manifest_batches):
+        logger.info(f"Writing {len(manifest.payload)} tables to batch {i} manifest...")
+
+        with open(f"database_table_manifest__batch_{i}.json", "w") as f:
+            f.write(manifest.json())