pvw-cli 1.0.4__py3-none-any.whl → 1.0.8__py3-none-any.whl

purviewcli/cli/data_product.py

@@ -1,278 +0,0 @@
-import click
-import csv
-import json
-import tempfile
-import os
-from rich.console import Console
-from purviewcli.client._unified_catalog import UnifiedCatalogDataProduct
-
-console = Console()
-
-@click.group()
-def data_product():
-    """Manage data products in Microsoft Purview using Unified Catalog API."""
-    pass
-
-@data_product.command()
-@click.option('--name', required=True, help="Name of the data product")
-@click.option('--description', required=False, help="Description of the data product")
-@click.option('--domain-guid', required=False, help="GUID of the domain to associate with")
-def create(name, description, domain_guid):
-    """Create a new data product using Unified Catalog API."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.create_data_product(
-            name=name,
-            description=description,
-            domain_guid=domain_guid
-        )
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Created data product '{name}'")
-        console.print(json.dumps(result, indent=2))
-            
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--data-product-id', required=True, help="ID of the data product")
-def show(data_product_id):
-    """Show details of a data product using Unified Catalog API."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.get_data_product(data_product_id)
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--data-product-id', required=True, help="ID of the data product")
-@click.option('--name', required=False, help="New name for the data product")
-@click.option('--description', required=False, help="New description for the data product")
-def update(data_product_id, name, description):
-    """Update a data product using Unified Catalog API."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        updates = {}
-        if name:
-            updates['name'] = name
-        if description:
-            updates['description'] = description
-        
-        if not updates:
-            console.print("[yellow]WARNING:[/yellow] No updates specified")
-            return
-        
-        result = data_product_client.update_data_product(data_product_id, updates)
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Updated data product '{data_product_id}'")
-        console.print(json.dumps(result, indent=2))
-            
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--data-product-id', required=True, help="ID of the data product")
-def delete(data_product_id):
-    """Delete a data product using Unified Catalog API."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.delete_data_product(data_product_id)
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Deleted data product '{data_product_id}'")
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--limit', default=50, help="Maximum number of data products to list")
-@click.option('--skip', default=0, help="Number of data products to skip")
-@click.option('--domain-id', required=False, help="Filter by governance domain ID")
-def list(limit, skip, domain_id):
-    """List data products using Unified Catalog API."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.list_data_products(
-            limit=limit,
-            offset=skip,
-            domain_id=domain_id
-        )
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--data-product-id', required=True, help="ID of the data product")
-def publish(data_product_id):
-    """Publish a data product using Unified Catalog API."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.update_data_product(data_product_id, {"status": "Published"})
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Published data product '{data_product_id}'")
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--data-product-id', required=True, help="ID of the data product")
-def unpublish(data_product_id):
-    """Unpublish a data product using Unified Catalog API."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.update_data_product(data_product_id, {"status": "Draft"})
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Unpublished data product '{data_product_id}'")
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-# === BUSINESS DOMAIN COMMANDS ===
-# Business domains are required for data product creation
-
-@data_product.command()
-def list_domains():
-    """List all business domains."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.businessDomainList({})
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--name', required=True, help="Name of the business domain")
-@click.option('--description', required=False, help="Description of the business domain")
-@click.option('--type', default="DataDomain", help="Type of the business domain (DataDomain, LineOfBusiness, etc.)")
-def create_domain(name, description, type):
-    """Create a new business domain."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        args = {
-            "--name": name,
-            "--description": description or "",
-            "--type": type,
-            "--status": "Draft"
-        }
-        result = data_product_client.businessDomainCreate(args)
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Created business domain '{name}'")
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--domain-id', required=True, help="ID of the business domain")
-def show_domain(domain_id):
-    """Show details of a business domain."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.businessDomainRead({"--domainId": domain_id})
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-# === GLOSSARY TERM COMMANDS ===
-
-@data_product.command()
-@click.option('--domain-id', required=False, help="Filter by governance domain ID")
-def list_terms(domain_id):
-    """List glossary terms."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        args = {}
-        if domain_id:
-            args["--governanceDomain"] = domain_id
-        result = data_product_client.glossaryTermsList(args)
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--name', required=True, help="Name of the glossary term")
-@click.option('--description', required=False, help="Description of the glossary term")
-@click.option('--domain-id', required=True, help="ID of the governance domain")
-def create_term(name, description, domain_id):
-    """Create a new glossary term."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.create_glossary_term(
-            name=name,
-            description=description or "",
-            domain_id=domain_id
-        )
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Created glossary term '{name}'")
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")
-
-@data_product.command()
-@click.option('--data-product-id', required=True, help="ID of the data product")
-@click.option('--term-id', required=True, help="ID of the glossary term")
-def link_term(data_product_id, term_id):
-    """Link a glossary term to a data product."""
-    try:
-        data_product_client = UnifiedCatalogDataProduct()
-        result = data_product_client.link_term_to_data_product(data_product_id, term_id)
-        
-        if result.get("status") == "error":
-            console.print(f"[red]ERROR:[/red] {result.get('message', 'Unknown error')}")
-            return
-            
-        console.print(f"[green]SUCCESS:[/green] Linked term '{term_id}' to data product '{data_product_id}'")
-        console.print(json.dumps(result, indent=2))
-    except Exception as e:
-        console.print(f"[red]ERROR:[/red] {str(e)}")

purviewcli/client/_data_product.py

@@ -1,168 +0,0 @@
-import json
-import tempfile
-import os
-import csv
-from purviewcli.client._entity import Entity
-
-class DataProduct:
-    """Client for managing data products in Microsoft Purview."""
-    
-    def __init__(self):
-        self.entity_client = Entity()
-
-    def import_from_csv(self, products):
-        with open("import_from_csv_debug.log", "a") as logf:
-            logf.write(f"products type: {type(products)}\n")
-            if products:
-                logf.write(f"first product type: {type(products[0])}\n")
-                logf.write(f"first product: {products[0]}\n")
-        if not isinstance(products, list):
-            raise TypeError(f"Expected a list, got: {type(products)} with value: {products}")
-        if not products or not isinstance(products[0], dict):
-            raise TypeError(
-                f"Expected a list of dicts, got: {type(products[0])} with value: {products[0]}"
-            )
-        required_fields = ["qualifiedName"]
-        entities = []
-        for product in products:
-            # Validate required fields
-            for field in required_fields:
-                if not product.get(field):
-                    raise ValueError(f"Missing required field '{field}' in row: {product}")
-            # Always use typeName DataSet (Purview default)
-            attributes = {k: v for k, v in product.items() if k != "typeName"}
-            entity = {
-                "typeName": "DataSet",
-                "attributes": attributes
-            }
-            entities.append(entity)
-        # Write the bulk payload to a temp file (always as {"entities": [...]})
-        bulk_payload = {"entities": entities}
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as tmpf:
-            json.dump(bulk_payload, tmpf, indent=2)
-            tmpf.flush()
-            payload_file = tmpf.name
-        try:
-            result = self.entity_client.entityCreateBulk({"--payloadFile": payload_file})
-            return [(e["attributes"]["qualifiedName"], result) for e in entities]
-        finally:
-            os.remove(payload_file)
-
-    def import_from_csv_file(self, csv_file_path, dry_run=False):
-        """Load data products from a CSV file and import them. If dry_run is True, return the parsed products only."""
-        with open(csv_file_path, 'r', encoding='utf-8') as f:
-            reader = csv.DictReader(f)
-            products = list(reader)
-        if dry_run:
-            return products
-        return self.import_from_csv(products)
-
-    def create(self, qualified_name, name=None, description=None, type_name="DataProduct"):
-        """Create a single data product entity."""
-        payload = {
-            "typeName": type_name,
-            "attributes": {
-                "qualifiedName": qualified_name,
-                "name": name or qualified_name,
-                "description": description or ""
-            },
-        }
-        # Write payload to temp file since entity client expects a file path
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as tmpf:
-            json.dump(payload, tmpf, indent=2)
-            tmpf.flush()
-            payload_file = tmpf.name
-        
-        try:
-            return self.entity_client.entityCreate({"--payloadFile": payload_file})
-        finally:
-            os.remove(payload_file)
-
-    def list(self, type_name="DataProduct"):
-        """List all data products (by typeName)."""
-        # Use the entity client's search method to find all entities of type DataProduct
-        search_args = {
-            "keywords": "*",  # match all
-            "filter": {
-                "entityType": [type_name]
-            },
-            "limit": 100
-        }
-        # If the entity client has a search method, use it; otherwise, return empty list
-        if hasattr(self.entity_client, "search_entities"):
-            return self.entity_client.search_entities(search_args)
-        # No suitable fallback for listing all entities by type; return empty list
-        return []
-
-    def show(self, qualified_name, type_name="DataProduct"):
-        """Show a data product by qualifiedName."""
-        args = {"--typeName": type_name, "--qualifiedName": qualified_name}
-        return self.entity_client.entityReadUniqueAttribute(args)
-
-    def delete(self, qualified_name, type_name="DataProduct"):
-        """Delete a data product by qualifiedName."""
-        args = {"--typeName": type_name, "--qualifiedName": qualified_name}
-        return self.entity_client.entityDeleteUniqueAttribute(args)
-
-    def add_classification(self, qualified_name, classification, type_name="DataProduct"):
-        """Add a classification to a data product."""
-        args = {
-            "--typeName": type_name,
-            "--qualifiedName": qualified_name,
-            "--payloadFile": {"classifications": [classification]}
-        }
-        return self.entity_client.entityAddClassificationsByUniqueAttribute(args)
-
-    def remove_classification(self, qualified_name, classification, type_name="DataProduct"):
-        """Remove a classification from a data product."""
-        args = {
-            "--typeName": type_name,
-            "--qualifiedName": qualified_name,
-            "--classificationName": classification
-        }
-        return self.entity_client.entityDeleteClassificationByUniqueAttribute(args)
-
-    def add_label(self, qualified_name, label, type_name="DataProduct"):
-        """Add a label to a data product."""
-        args = {
-            "--typeName": type_name,
-            "--qualifiedName": qualified_name,
-            "--payloadFile": {"labels": [label]}
-        }
-        return self.entity_client.entityAddLabelsByUniqueAttribute(args)
-
-    def remove_label(self, qualified_name, label, type_name="DataProduct"):
-        """Remove a label from a data product."""
-        args = {
-            "--typeName": type_name,
-            "--qualifiedName": qualified_name,
-            "--payloadFile": {"labels": [label]}
-        }
-        return self.entity_client.entityRemoveLabelsByUniqueAttribute(args)
-
-    def link_glossary(self, qualified_name, term, type_name="DataProduct"):
-        """Link a glossary term to a data product."""
-        # This assumes business metadata or a custom attribute for glossary terms
-        # You may need to adjust this to your Purview model
-        args = {
-            "--typeName": type_name,
-            "--qualifiedName": qualified_name,
-            "--payloadFile": {"meanings": [term]}
-        }
-        return self.entity_client.entityPartialUpdateByUniqueAttribute(args)
-
-    def show_lineage(self, qualified_name, type_name="DataProduct"):
-        """Show lineage for a data product."""
-        args = {"--typeName": type_name, "--qualifiedName": qualified_name}
-        # This assumes you have a lineage client or can call entityReadUniqueAttribute and extract lineage
-        # For now, just return the entity details
-        return self.entity_client.entityReadUniqueAttribute(args)
-
-    def set_status(self, qualified_name, status, type_name="DataProduct"):
-        """Set the status of a data product (e.g., active, deprecated)."""
-        args = {
-            "--typeName": type_name,
-            "--qualifiedName": qualified_name,
-            "--payloadFile": {"status": status}
-        }
-        return self.entity_client.entityPartialUpdateByUniqueAttribute(args)