semantic-link-labs 0.12.8__py3-none-any.whl

sempy_labs/report/_save_report.py

@@ -0,0 +1,147 @@
+import os
+import base64
+import json
+import sempy.fabric as fabric
+import sempy_labs._icons as icons
+from sempy_labs.report._generate_report import get_report_definition
+from sempy_labs._generate_semantic_model import get_semantic_model_definition
+from sempy_labs._helper_functions import (
+    _mount,
+    resolve_workspace_name_and_id,
+    resolve_item_name,
+    resolve_workspace_name,
+    resolve_item_name_and_id,
+)
+from uuid import UUID
+from sempy._utils._log import log
+from typing import Optional
+
+
+@log
+def save_report_as_pbip(
+    report: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    thick_report: bool = True,
+    live_connect: bool = True,
+    lakehouse: Optional[str | UUID] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
+):
+    """
+    Saves a report as a .pbip file to the default lakehouse attached to the notebook.
+
+    Parameters
+    ----------
+    report : str | uuid.UUID
+        Name or ID of the Power BI report.
+    workspace : str | uuid.UUID, default=None
+        The name or ID of the Fabric workspace in which the report resides.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    thick_report : bool, default=True
+        If set to True, saves the report and underlying semantic model.
+        If set to False, saves just the report.
+    live_connect : bool, default=True
+        If set to True, saves a .pbip live-connected to the workspace in the Power BI / Fabric service.
+        If set to False, saves a .pbip with a local model, independent from the Power BI / Fabric service.
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID. This will be the lakehouse to which the report is saved.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    lakehouse_workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    (report_workspace_name, report_workspace_id) = resolve_workspace_name_and_id(
+        workspace
+    )
+    (report_name, report_id) = resolve_item_name_and_id(
+        item=report, type="Report", workspace=workspace
+    )
+    indent = 2
+
+    local_path = _mount(lakehouse=lakehouse, workspace=lakehouse_workspace)
+    save_location = f"{local_path}/Files"
+
+    # Find semantic model info
+    dfR = fabric.list_reports(workspace=workspace)
+    dfR_filt = dfR[dfR["Id"] == report_id]
+    if dfR_filt.empty:
+        raise ValueError(
+            f"{icons.red_dot} The '{report} report does not exist within the '{report_workspace_name} workspace."
+        )
+
+    dataset_id = dfR_filt["Dataset Id"].iloc[0]
+    dataset_workspace_id = dfR_filt["Dataset Workspace Id"].iloc[0]
+    dataset_name = resolve_item_name(item_id=dataset_id, workspace=dataset_workspace_id)
+    dataset_workspace_name = resolve_workspace_name(dataset_workspace_id)
+    path_prefix = f"{save_location}/{report_workspace_name}/{report_name}/{report_name}"
+
+    # Local model not supported if the report and model are in different workspaces
+    if dataset_workspace_name != report_workspace_name and not live_connect:
+        live_connect = True
+        print(
+            f"{icons.warning} The '{report_name}' report from the '{report_workspace_name}' workspace is being saved as a live-connected report/model."
+        )
+
+    def add_files(name, type, object_workspace):
+
+        path_prefix_full = f"{path_prefix}.{type}"
+
+        if type == "Report":
+            dataframe = get_report_definition(report=name, workspace=workspace)
+        elif type == "SemanticModel":
+            dataframe = get_semantic_model_definition(
+                dataset=name, workspace=object_workspace
+            )
+        else:
+            raise NotImplementedError
+
+        # Create and save files based on dataset/report definition
+        for _, r in dataframe.iterrows():
+            path = r["path"]
+            file_content = base64.b64decode(r["payload"])
+            file_path = f"{path_prefix_full}/{path}"
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+            # Update the definition.pbir file for local models
+            if not live_connect and type == "Report" and path == "definition.pbir":
+                file_content = {
+                    "version": "1.0",
+                    "datasetReference": {
+                        "byPath": {"path": f"../{report_name}.SemanticModel"},
+                        "byConnection": None,
+                    },
+                }
+
+                with open(file_path, "w") as f:
+                    json.dump(file_content, f, indent=indent)
+            else:
+                with open(file_path, "wb") as f:
+                    f.write(file_content)
+
+        # Create and save .pbip file for report, converting the file extension
+        if type == "Report":
+            # Standard .pbip file content
+            pbip = {
+                "version": "1.0",
+                "artifacts": [{"report": {"path": f"{report_name}.Report"}}],
+                "settings": {"enableAutoRecovery": True},
+            }
+            # Ensure the directory exists
+            os.makedirs(os.path.dirname(path_prefix), exist_ok=True)
+            # Write the .pbip file directly
+            pbip_final = f"{path_prefix}.pbip"
+            with open(pbip_final, "w") as file:
+                json.dump(pbip, file, indent=indent)
+
+    add_files(name=report_name, type="Report", object_workspace=workspace)
+    if thick_report:
+        add_files(
+            name=dataset_name,
+            type="SemanticModel",
+            object_workspace=dataset_workspace_name,
+        )
+    print(
+        f"{icons.green_dot} The '{report_name}' report within the '{report_workspace_name}' workspace has been saved to this location: {save_location}."
+    )

sempy_labs/snowflake_database/__init__.py

@@ -0,0 +1,10 @@
+from ._items import (
+    list_snowflake_databases,
+    delete_snowflake_database,
+)
+
+
+__all__ = [
+    "list_snowflake_databases",
+    "delete_snowflake_database",
+]

sempy_labs/snowflake_database/_items.py

@@ -0,0 +1,105 @@
+from sempy_labs._helper_functions import (
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+    delete_item,
+    resolve_workspace_id,
+)
+import pandas as pd
+from typing import Optional
+from uuid import UUID
+from sempy._utils._log import log
+
+
+@log
+def list_snowflake_databases(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Shows the snowflake databases within a workspace.
+
+    This is a wrapper function for the following API: `Items - List Snowflake Databases <https://learn.microsoft.com/rest/api/fabric/snowflakedatabase/items/list-snowflake-databases>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing the snowflake databases within a workspace.
+    """
+
+    columns = {
+        "Snowflake Database Display Name": "string",
+        "Snowflake Database Id": "string",
+        "Description": "string",
+        "Snowflake Database Name": "string",
+        "OneLake Tables Path": "string",
+        "Snowflake Volume Path": "string",
+        "SQL Endpoint Connection String": "string",
+        "SQL Endpoint Id": "string",
+        "SQL Endpoint Provisioning Status": "string",
+        "Default Schema": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    workspace_id = resolve_workspace_id(workspace)
+
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/snowflakeDatabases",
+        uses_pagination=True,
+        client="fabric_sp",
+    )
+
+    rows = []
+    for r in responses:
+        for v in r.get("value", []):
+            prop = v.get("properties", {})
+
+            rows.append(
+                {
+                    "Snowflake Database Display Name": v.get("displayName"),
+                    "Snowflake Database Id": v.get("id"),
+                    "Description": v.get("description"),
+                    "Snowflake Database Name": prop.get("snowflakeDatabaseName"),
+                    "OneLake Tables Path": prop.get("onelakeTablesPath"),
+                    "Snowflake Volume Path": prop.get("snowflakeVolumePath"),
+                    "SQL Endpoint Connection String": prop.get(
+                        "sqlEndpointProperties", {}
+                    ).get("connectionString"),
+                    "SQL Endpoint Id": prop.get("sqlEndpointProperties", {}).get("id"),
+                    "SQL Endpoint Provisioning Status": prop.get(
+                        "sqlEndpointProperties", {}
+                    ).get("provisioningStatus"),
+                    "Default Schema": prop.get("defaultSchema"),
+                }
+            )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+        _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+@log
+def delete_snowflake_database(
+    snowflake_database: str | UUID, workspace: Optional[str | UUID] = None
+):
+    """
+    Deletes a Fabric snowflake database.
+
+    This is a wrapper function for the following API: `Items - Delete Snowflake Database <https://learn.microsoft.com/rest/api/fabric/snowflakedatabase/items/delete-snowflake-database>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+    """
+
+    delete_item(
+        item=snowflake_database,
+        type="SnowflakeDatabase",
+        workspace=workspace,
+    )

sempy_labs/sql_database/__init__.py

@@ -0,0 +1,21 @@
+from sempy_labs.sql_database._items import (
+    get_sql_database_columns,
+    get_sql_database_tables,
+    create_sql_database,
+    delete_sql_database,
+    list_sql_databases,
+)
+from sempy_labs.sql_database._mirroring import (
+    start_mirroring,
+    stop_mirroring,
+)
+
+__all__ = [
+    "get_sql_database_columns",
+    "get_sql_database_tables",
+    "create_sql_database",
+    "delete_sql_database",
+    "list_sql_databases",
+    "start_mirroring",
+    "stop_mirroring",
+]

sempy_labs/sql_database/_items.py

@@ -0,0 +1,201 @@
+from sempy_labs._helper_functions import (
+    resolve_workspace_id,
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+    create_item,
+    delete_item,
+)
+import pandas as pd
+from typing import Optional
+from uuid import UUID
+from sempy._utils._log import log
+
+
+@log
+def create_sql_database(
+    name: str, description: Optional[str] = None, workspace: Optional[str | UUID] = None
+):
+    """
+    Creates a SQL database.
+
+    This is a wrapper function for the following API: `Items - Create SQL Database <https://learn.microsoft.com/rest/api/fabric/sqldatabase/items/create-sql-database>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    name: str
+        Name of the SQL database.
+    description : str, default=None
+        A description of the SQL database.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    create_item(
+        name=name, description=description, type="SQLDatabase", workspace=workspace
+    )
+
+
+@log
+def delete_sql_database(
+    sql_database: str | UUID, workspace: Optional[str | UUID] = None
+):
+    """
+    Deletes a SQL Database.
+
+    This is a wrapper function for the following API: `Items - Delete SQL Database <https://learn.microsoft.com/rest/api/fabric/sqldatabase/items/delete-sql-database>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    sql_database: str | uuid.UUID
+        Name of the SQL database.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    delete_item(item=sql_database, type="SQLDatabase", workspace=workspace)
+
+
+@log
+def list_sql_databases(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Lists all SQL databases in the Fabric workspace.
+
+    This is a wrapper function for the following API: `Items - List SQL Databases <https://learn.microsoft.com/rest/api/fabric/sqldatabase/items/list-sql-databases>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of SQL databases in the Fabric workspace.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+
+    columns = {
+        "SQL Database Name": "string",
+        "SQL Database Id": "string",
+        "Description": "string",
+        "Connection Info": "string",
+        "Database Name": "string",
+        "Server FQDN": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/SQLDatabases",
+        uses_pagination=True,
+        client="fabric_sp",
+    )
+
+    rows = []
+    for r in responses:
+        for v in r.get("value", []):
+            prop = v.get("properties", {})
+            rows.append(
+                {
+                    "SQL Database Name": v.get("displayName"),
+                    "SQL Database Id": v.get("id"),
+                    "Description": v.get("description"),
+                    "Connection Info": prop.get("connectionInfo"),
+                    "Database Name": prop.get("databaseName"),
+                    "Server FQDN": prop.get("serverFqdn"),
+                }
+            )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+        _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+@log
+def get_sql_database_tables(
+    sql_database: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a list of the tables in the Fabric SQLDabatse. This function is based on INFORMATION_SCHEMA.TABLES.
+
+    Parameters
+    ----------
+    sql_database : str | uuid.UUID
+        Name or ID of the Fabric SQLDabatase.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of the tables in the Fabric SQLDabatase.
+    """
+
+    from sempy_labs._sql import ConnectSQLDatabase
+
+    with ConnectSQLDatabase(sql_database=sql_database, workspace=workspace) as sql:
+        df = sql.query(
+            """
+        SELECT TABLE_SCHEMA AS [Schema], TABLE_NAME AS [Table Name], TABLE_TYPE AS [Table Type]
+        FROM INFORMATION_SCHEMA.TABLES
+        WHERE TABLE_TYPE = 'BASE TABLE'
+        """
+        )
+
+    return df
+
+
+@log
+def get_sql_database_columns(
+    sql_database: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a list of the columns in each table within the Fabric SQLDabatase. This function is based on INFORMATION_SCHEMA.COLUMNS.
+
+    Parameters
+    ----------
+    sql_database : str | uuid.UUID
+        Name or ID of the Fabric SQLDabatase.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of the columns in each table within the Fabric SQLDabatase.
+    """
+
+    from sempy_labs._sql import ConnectSQLDatabase
+
+    with ConnectSQLDatabase(sql_database=sql_database, workspace=workspace) as sql:
+        df = sql.query(
+            """
+        SELECT t.TABLE_SCHEMA AS [Schema], t.TABLE_NAME AS [Table Name], c.COLUMN_NAME AS [Column Name], c.DATA_TYPE AS [Data Type], c.IS_NULLABLE AS [Is Nullable], c.CHARACTER_MAXIMUM_LENGTH AS [Character Max Length]
+        FROM INFORMATION_SCHEMA.TABLES AS t
+        LEFT JOIN INFORMATION_SCHEMA.COLUMNS AS c
+        ON t.TABLE_NAME = c.TABLE_NAME
+        AND t.TABLE_SCHEMA = c.TABLE_SCHEMA
+        WHERE t.TABLE_TYPE = 'BASE TABLE'
+        """
+        )
+
+    return df

sempy_labs/sql_database/_mirroring.py

@@ -0,0 +1,79 @@
+from sempy_labs._helper_functions import (
+    resolve_item_id,
+    _base_api,
+    resolve_workspace_name_and_id,
+)
+from typing import Optional
+from uuid import UUID
+from sempy._utils._log import log
+import sempy_labs._icons as icons
+
+
+@log
+def start_mirroring(sql_database: str | UUID, workspace: Optional[str | UUID] = None):
+    """
+    Starts data mirroring for the specified SQL Database.
+
+    This is a wrapper function for the following API: `Mirroring - Start Mirroring <https://learn.microsoft.com/rest/api/fabric/sqldatabase/mirroring/start-mirroring>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    sql_database : str | uuid.UUID
+        Name or ID of the SQL Database.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    item_id = resolve_item_id(
+        item=sql_database, type="SQLDatabase", workspace=workspace_id
+    )
+
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/sqlDatabases/{item_id}/startMirroring",
+        method="post",
+        client="fabric_sp",
+    )
+
+    print(
+        f"{icons.green_dot} The SQL Database '{sql_database}' in the '{workspace_name}' workspace is now being mirrored."
+    )
+
+
+@log
+def stop_mirroring(sql_database: str | UUID, workspace: Optional[str | UUID] = None):
+    """
+    Stops data mirroring for the specified SQL Database.
+
+    This is a wrapper function for the following API: `Mirroring - Stop Mirroring <https://learn.microsoft.com/rest/api/fabric/sqldatabase/mirroring/stop-mirroring>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    sql_database : str | uuid.UUID
+        Name or ID of the SQL Database.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    item_id = resolve_item_id(
+        item=sql_database, type="SQLDatabase", workspace=workspace_id
+    )
+
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/sqlDatabases/{item_id}/stopMirroring",
+        method="post",
+        client="fabric_sp",
+    )
+
+    print(
+        f"{icons.green_dot} The SQL Database '{sql_database}' in the '{workspace_name}' workspace is no longer being mirrored."
+    )

sempy_labs/theme/__init__.py

@@ -0,0 +1,12 @@
+from ._org_themes import (
+    list_org_themes,
+    get_org_theme_json,
+    resolve_theme_id,
+)
+
+
+__all__ = [
+    "list_org_themes",
+    "get_org_theme_json",
+    "resolve_theme_id",
+]