semantic-link-labs 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

sempy_labs/_mounted_data_factories.py

@@ -0,0 +1,119 @@
+import pandas as pd
+import json
+from typing import Optional
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+    resolve_item_id,
+    _decode_b64,
+    delete_item,
+    get_item_definition,
+)
+
+from uuid import UUID
+
+
+def list_mounted_data_factories(
+    workspace: Optional[str | UUID] = None,
+) -> pd.DataFrame:
+    """
+    Shows a list of mounted data factories from the specified workspace.
+
+    This is a wrapper function for the following API: `Items - List Mounted Data Factories <https://learn.microsoft.com/rest/api/fabric/mounteddatafactory/items/list-mounted-data-factories>`_.
+
+    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 mounted data factories from the specified workspace.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    columns = {
+        "Mounted Data Factory Name": "str",
+        "Mounted Data Factory Id": "str",
+        "Description": "str",
+    }
+
+    df = _create_dataframe(columns=columns)
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/mountedDataFactories",
+        uses_pagination=True,
+    )
+
+    for r in responses:
+        for v in r.get("value", []):
+            new_data = {
+                "Mounted Data Factory Name": v.get("displayName"),
+                "Mounted Data Factory Id": v.get("id"),
+                "Description": v.get("description"),
+            }
+
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+def get_mounted_data_factory_definition(
+    mounted_data_factory: str | UUID, workspace: Optional[str | UUID] = None
+) -> dict:
+    """
+    Returns the specified MountedDataFactory public definition.
+
+    This is a wrapper function for the following API: `Items - Get Mounted Data Factory Definition <https://learn.microsoft.com/rest/api/fabric/mounteddatafactory/items/get-mounted-data-factory-definition>`_.
+
+    Parameters
+    ----------
+    mounted_data_factory : str | uuid.UUID
+        The name or ID of the mounted data factory.
+    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
+    -------
+    dict
+        The 'mountedDataFactory-content.json' file from the mounted data factory definition.
+    """
+
+    return get_item_definition(
+        item=mounted_data_factory,
+        type="MountedDataFactory",
+        workspace=workspace,
+        return_dataframe=False,
+    )
+
+
+def delete_mounted_data_factory(
+    mounted_data_factory: str | UUID, workspace: Optional[str | UUID]
+):
+    """
+    Deletes the specified mounted data factory.
+
+    This is a wrapper function for the following API: `Items - Delete Mounted Data Factory <https://learn.microsoft.com/rest/api/fabric/mounteddatafactory/items/delete-mounted-data-factory>`_.
+
+    Parameters
+    ----------
+    mounted_data_factory : str | uuid.UUID
+        The name or ID of the mounted data factory.
+    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=mounted_data_factory, type="MountedDataFactory", workspace=workspace
+    )

sempy_labs/_notebooks.py

@@ -10,6 +10,7 @@ from sempy_labs._helper_functions import (
     _decode_b64,
     _base_api,
     resolve_item_id,
+    create_item,
 )
 from sempy.fabric.exceptions import FabricHTTPException
 import os
@@ -183,35 +184,24 @@ def create_notebook(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     notebook_payload = base64.b64encode(notebook_content).decode("utf-8")
-
-    payload = {
-        "displayName": name,
-        "definition": {
-            "format": "ipynb",
-            "parts": [
-                {
-                    "path": f"{_notebook_prefix}.{type}",
-                    "payload": notebook_payload,
-                    "payloadType": "InlineBase64",
-                }
-            ],
-        },
+    definition_payload = {
+        "format": "ipynb",
+        "parts": [
+            {
+                "path": f"{_notebook_prefix}.{type}",
+                "payload": notebook_payload,
+                "payloadType": "InlineBase64",
+            }
+        ],
     }
-    if description is not None:
-        payload["description"] = description
 
-    _base_api(
-        request=f"v1/workspaces/{workspace_id}/notebooks",
-        payload=payload,
-        method="post",
-        lro_return_status_code=True,
-        status_codes=[201, 202],
-    )
-
-    print(
-        f"{icons.green_dot} The '{name}' notebook was created within the '{workspace_name}' workspace."
+    create_item(
+        name=name,
+        type="Notebook",
+        workspace=workspace,
+        description=description,
+        definition=definition_payload,
     )
 
 

sempy_labs/_semantic_models.py

@@ -0,0 +1,117 @@
+from uuid import UUID
+from typing import Optional
+import pandas as pd
+from sempy_labs._helper_functions import (
+    _create_dataframe,
+    _base_api,
+    _update_dataframe_datatypes,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+)
+import sempy_labs._icons as icons
+
+
+def get_semantic_model_refresh_schedule(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Gets the refresh schedule for the specified dataset from the specified workspace.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The 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
+        Shows the refresh schedule for the specified dataset from the specified workspace.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace)
+
+    columns = {
+        "Days": "str",
+        "Times": "str",
+        "Enabled": "bool",
+        "Local Time Zone Id": "str",
+        "Notify Option": "str",
+    }
+
+    column_map = {
+        "days": "Days",
+        "times": "Times",
+        "enabled": "Enabled",
+        "localTimeZoneId": "Local Time Zone Id",
+        "notifyOption": "Notify Option",
+    }
+
+    df = _create_dataframe(columns)
+
+    result = _base_api(
+        request=f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}/refreshSchedule"
+    ).json()
+
+    df = (
+        pd.json_normalize(result)
+        .drop(columns=["@odata.context"], errors="ignore")
+        .rename(columns=column_map)
+    )
+
+    _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+def enable_semantic_model_scheduled_refresh(
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    enable: bool = True,
+):
+    """
+    Enables the scheduled refresh for the specified dataset from the specified workspace.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The 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.
+    enable : bool, default=True
+        If True, enables the scheduled refresh.
+        If False, disables the scheduled refresh.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace)
+
+    df = get_semantic_model_refresh_schedule(dataset=dataset, workspace=workspace)
+    status = df["Enabled"].iloc[0]
+
+    if enable and status:
+        print(
+            f"{icons.info} Scheduled refresh for the '{dataset_name}' within the '{workspace_name}' workspace is already enabled."
+        )
+    elif not enable and not status:
+        print(
+            f"{icons.info} Scheduled refresh for the '{dataset_name}' within the '{workspace_name}' workspace is already disabled."
+        )
+    else:
+        payload = {"value": {"enabled": enable}}
+
+        _base_api(
+            request=f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}/refreshSchedule",
+            method="patch",
+            payload=payload,
+        )
+
+        print(
+            f"{icons.green_dot} Scheduled refresh for the '{dataset_name}' within the '{workspace_name}' workspace has been enabled."
+        )

sempy_labs/_sql.py

@@ -34,7 +34,7 @@ def _bytes2mswin_bstr(value: bytes) -> bytes:
 class ConnectBase:
     def __init__(
         self,
-        item: str,
+        item: str | UUID,
         workspace: Optional[Union[str, UUID]] = None,
         timeout: Optional[int] = None,
         endpoint_type: str = "warehouse",
@@ -45,13 +45,19 @@ class ConnectBase:
         (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
         # Resolve the appropriate ID and name (warehouse or lakehouse)
-        if endpoint_type == "warehouse":
+        if endpoint_type == "sqldatabase":
+            # SQLDatabase is has special case for resolving the name and id
             (resource_name, resource_id) = resolve_item_name_and_id(
-                item=item, type=endpoint_type.capitalize(), workspace=workspace_id
+                item=item, type="SQLDatabase", workspace=workspace_id
             )
-        else:
+        elif endpoint_type == "lakehouse":
             (resource_name, resource_id) = resolve_lakehouse_name_and_id(
-                lakehouse=item, workspace=workspace_id
+                lakehouse=item,
+                workspace=workspace_id,
+            )
+        else:
+            (resource_name, resource_id) = resolve_item_name_and_id(
+                item=item, workspace=workspace_id, type=endpoint_type.capitalize()
             )
 
         # Get the TDS endpoint
@@ -61,6 +67,8 @@ class ConnectBase:
 
         if endpoint_type == "warehouse":
             tds_endpoint = response.json().get("properties", {}).get("connectionString")
+        if endpoint_type == "sqldatabase":
+            tds_endpoint = response.json().get("properties", {}).get("serverFqdn")
         else:
             tds_endpoint = (
                 response.json()
@@ -72,7 +80,10 @@ class ConnectBase:
         # Set up the connection string
         access_token = SynapseTokenProvider()()
         tokenstruct = _bytes2mswin_bstr(access_token.encode())
-        conn_str = f"DRIVER={{ODBC Driver 18 for SQL Server}};SERVER={tds_endpoint};DATABASE={resource_name};Encrypt=Yes;"
+        if endpoint_type == "sqldatabase":
+            conn_str = f"DRIVER={{ODBC Driver 18 for SQL Server}};SERVER={tds_endpoint};DATABASE={resource_name}-{resource_id};Encrypt=Yes;"
+        else:
+            conn_str = f"DRIVER={{ODBC Driver 18 for SQL Server}};SERVER={tds_endpoint};DATABASE={resource_name};Encrypt=Yes;"
 
         if timeout is not None:
             conn_str += f"Connect Timeout={timeout};"
@@ -141,10 +152,24 @@ class ConnectBase:
 class ConnectWarehouse(ConnectBase):
     def __init__(
         self,
-        warehouse: str,
+        warehouse: str | UUID,
         workspace: Optional[Union[str, UUID]] = None,
-        timeout: Optional[int] = None,
+        timeout: int = 30,
     ):
+        """
+        Run a SQL or T-SQL query against a Fabric Warehouse.
+
+        Parameters
+        ----------
+        warehouse : str | uuid.UUID
+            The name or ID of the Fabric warehouse.
+        workspace : str | uuid.UUID, default=None
+            The name or ID of the workspace.
+            Defaults to None which resolves to the workspace of the attached lakehouse
+            or if no lakehouse attached, resolves to the workspace of the notebook.
+        timeout : int, default=30
+            The timeout for the connection in seconds.
+        """
         super().__init__(
             item=warehouse,
             workspace=workspace,
@@ -156,13 +181,56 @@ class ConnectWarehouse(ConnectBase):
 class ConnectLakehouse(ConnectBase):
     def __init__(
         self,
-        lakehouse: str,
+        lakehouse: str | UUID,
         workspace: Optional[Union[str, UUID]] = None,
-        timeout: Optional[int] = None,
+        timeout: int = 30,
     ):
+        """
+        Run a SQL or T-SQL query against a Fabric lakehouse.
+
+        Parameters
+        ----------
+        lakehouse : str | uuid.UUID
+            The name or ID of the Fabric lakehouse.
+        workspace : str | uuid.UUID, default=None
+            The name or ID of the workspace.
+            Defaults to None which resolves to the workspace of the attached lakehouse
+            or if no lakehouse attached, resolves to the workspace of the notebook.
+        timeout : int, default=30
+            The timeout for the connection in seconds.
+        """
         super().__init__(
             item=lakehouse,
             workspace=workspace,
             timeout=timeout,
             endpoint_type="lakehouse",
         )
+
+
+class ConnectSQLDatabase(ConnectBase):
+    def __init__(
+        self,
+        sql_database: str | UUID,
+        workspace: Optional[Union[str, UUID]] = None,
+        timeout: int = 30,
+    ):
+        """
+        Run a SQL or T-SQL query against a Fabric SQL database.
+
+        Parameters
+        ----------
+        sql_database : str | uuid.UUID
+            The name or ID of the Fabric SQL database.
+        workspace : str | uuid.UUID, default=None
+            The name or ID of the workspace.
+            Defaults to None which resolves to the workspace of the attached lakehouse
+            or if no lakehouse attached, resolves to the workspace of the notebook.
+        timeout : int, default=30
+            The timeout for the connection in seconds.
+        """
+        super().__init__(
+            item=sql_database,
+            workspace=workspace,
+            timeout=timeout,
+            endpoint_type="sqldatabase",
+        )

sempy_labs/_sqldatabase.py

@@ -0,0 +1,227 @@
+import sempy.fabric as fabric
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+)
+import pandas as pd
+from typing import Optional
+import sempy_labs._icons as icons
+from uuid import UUID
+
+## Still debugging the creation of an sql database
+# def create_warehouse(
+#     warehouse: str,
+#     description: Optional[str] = None,
+#     case_insensitive_collation: bool = False,
+#     workspace: Optional[str | UUID] = None,
+# ):
+#     """
+#     Creates a Fabric warehouse.
+
+#     This is a wrapper function for the following API: `Items - Create Warehouse <https://learn.microsoft.com/rest/api/fabric/warehouse/items/create-warehouse>`_.
+
+#     Parameters
+#     ----------
+#     warehouse: str
+#         Name of the warehouse.
+#     description : str, default=None
+#         A description of the warehouse.
+#     case_insensitive_collation: bool, default=False
+#         If True, creates the warehouse with case-insensitive collation.
+#     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)
+
+#     payload = {"displayName": warehouse}
+
+#     if description:
+#         payload["description"] = description
+#     if case_insensitive_collation:
+#         payload.setdefault("creationPayload", {})
+#         payload["creationPayload"][
+#             "defaultCollation"
+#         ] = "Latin1_General_100_CI_AS_KS_WS_SC_UTF8"
+
+#     _base_api(
+#         request=f"/v1/workspaces/{workspace_id}/warehouses",
+#         payload=payload,
+#         method="post",
+#         lro_return_status_code=True,
+#         status_codes=[201, 202],
+#     )
+
+#     print(
+#         f"{icons.green_dot} The '{warehouse}' warehouse has been created within the '{workspace_name}' workspace."
+#     )
+
+
+def _list_sql_databases(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Shows the databses within a workspace.
+
+
+    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 SQLDabatases within a workspace.
+    """
+
+    columns = {
+        "SQL Database Name": "string",
+        "SQL Database Id": "string",
+        "Description": "string",
+        "Connection Type": "string",
+        "Connection Info": "string",
+        "Database Name": "string",
+        "Server FQDN": "string",
+        "Provisioning Status": "string",
+        "Created Date": "datetime",
+        "Last Updated Time UTC": "datetime",
+    }
+    df = _create_dataframe(columns=columns)
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/sqldatabases", uses_pagination=True
+    )
+
+    for r in responses:
+        for v in r.get("value", []):
+            prop = v.get("properties", {})
+
+            new_data = {
+                "SQL Database Name": v.get("displayName"),
+                "SQL Database Id": v.get("id"),
+                "Description": v.get("description"),
+                "Connection Type": v.get("type"),
+                "Connection Info": prop.get("connectionInfo"),
+                "Database Name": prop.get("databaseName"),
+                "Server FQDN": prop.get("serverFqdn"),
+                "Provisioning Status": prop.get("provisioningState"),
+                "Created Date": prop.get("createdDate"),
+                "Last Updated Time UTC": prop.get("lastUpdatedTimeUtc"),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+## Still debugging the deletion of an sql database
+# def delete_warehouse(name: str, workspace: Optional[str | UUID] = None):
+#     """
+#     Deletes a Fabric warehouse.
+
+#     This is a wrapper function for the following API: `Items - Delete Warehouse <https://learn.microsoft.com/rest/api/fabric/warehouse/items/delete-warehouse>`_.
+
+#     Parameters
+#     ----------
+#     name: str
+#         Name of the warehouse.
+#     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 = fabric.resolve_item_id(
+#         item_name=name, type="Warehouse", workspace=workspace_id
+#     )
+
+#     _base_api(
+#         request=f"/v1/workspaces/{workspace_id}/warehouses/{item_id}", method="delete"
+#     )
+
+#     print(
+#         f"{icons.green_dot} The '{name}' warehouse within the '{workspace_name}' workspace has been deleted."
+#     )
+
+
+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
+
+
+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