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

purviewcli/client/_search.py

@@ -33,27 +33,48 @@ class Search(Endpoint):
         self.endpoint = ENDPOINTS["discovery"]["query"]
         self.params = get_api_version_params("datamap")
         
-        # Build search payload
+        # Check if direct payload is provided
+        if args.get("--payload"):
+            import json
+            self.payload = json.loads(args["--payload"])
+            return
+        
+        # Check if payload file is provided
+        if args.get("--payloadFile"):
+            self.payload = get_json(args, "--payloadFile")
+            return
+        
+        # Build search payload from individual parameters
+        # Support both '--keywords' and the CLI shorthand '--query'
+        keywords = args.get("--keywords") if args.get("--keywords") is not None else args.get("--query")
+        if keywords is None:
+            keywords = "*"
+
         search_request = {
-            "keywords": args.get("--keywords", "*"),
+            "keywords": keywords,
             "limit": args.get("--limit", 50),
             "offset": args.get("--offset", 0),
-            "filter": {},
-            "facets": []
         }
         
+        # Only add filter if there are actual filter values
+        filter_obj = {}
+        
         # Add filters if provided
         if args.get("--filter"):
-            search_request["filter"] = self._parse_filter(args["--filter"])
+            filter_obj.update(self._parse_filter(args["--filter"]))
         
         if args.get("--entityType"):
-            search_request["filter"]["entityType"] = args["--entityType"]
+            filter_obj["entityType"] = args["--entityType"]
             
         if args.get("--classification"):
-            search_request["filter"]["classification"] = args["--classification"]
+            filter_obj["classification"] = args["--classification"]
             
         if args.get("--term"):
-            search_request["filter"]["term"] = args["--term"]
+            filter_obj["term"] = args["--term"]
+        
+        # Only include filter if it has content
+        if filter_obj:
+            search_request["filter"] = filter_obj
         
         # Add facets if requested
         if args.get("--facets"):

purviewcli/client/_unified_catalog.py

@@ -1,318 +1,269 @@
-import json
-import requests
-import os
-from .endpoint import Endpoint, get_data
-from .endpoints import ENDPOINTS, DATAMAP_API_VERSION
+"""
+Microsoft Purview Unified Catalog API Client
+Implements comprehensive Unified Catalog functionality
+"""
 
+from .endpoint import Endpoint, decorator, get_json, no_api_call_decorator
 
-class UnifiedCatalogDataProduct:
-    """
-    Microsoft Purview Unified Catalog Data Product client
-    Based on the actual Microsoft Purview Unified Catalog API structure
-    """
+
+class UnifiedCatalogClient(Endpoint):
+    """Client for Microsoft Purview Unified Catalog API."""
 
     def __init__(self):
-        """Initialize the unified catalog data product client"""
-        pass
-
-    def _make_request(self, method, endpoint, data=None, params=None):
-        """Make HTTP request through the existing infrastructure"""
-        try:
-            # Unified Catalog uses the Data Governance base path
-            base_path = "/datagovernance/catalog"
-            full_endpoint = base_path + endpoint
-            
-            http_dict = {
-                "method": method,
-                "endpoint": full_endpoint,
-                "params": params or {},
-                "payload": data
-            }
-            
-            # Add Unified Catalog API version to params
-            if "api-version" not in http_dict["params"]:
-                http_dict["params"]["api-version"] = DATAMAP_API_VERSION
-            
-            return get_data(http_dict)
-        except Exception as e:
-            return {
-                "status": "error",
-                "message": str(e),
-                "status_code": getattr(e, 'response', {}).get('status_code', 500) if hasattr(e, 'response') else 500
-            }
-
-    # === DATA PRODUCT OPERATIONS ===
-
-    def dataProductList(self, args):
-        """List data products with optional filtering"""
-        params = {}
-        if args.get("--limit"):
-            params["$top"] = args["--limit"]
-        if args.get("--skip"):
-            params["$skip"] = args["--skip"]
-        if args.get("--governanceDomain"):
-            params["domainId"] = args["--governanceDomain"]
-            
-        return self._make_request("GET", "/dataproducts", params=params)
-
-    def dataProductCreate(self, args):
-        """Create a new data product"""
-        payload = self._get_payload_from_args(args)
-        return self._make_request("POST", "/dataproducts", data=payload)
-
-    def dataProductRead(self, args):
-        """Get a data product by ID"""
-        data_product_id = args.get("--dataProductId")
-        if not data_product_id:
-            return {"status": "error", "message": "dataProductId is required"}
-        
-        endpoint = f"/dataproducts/{data_product_id}"
-        return self._make_request("GET", endpoint)
-
-    def dataProductUpdate(self, args):
-        """Update a data product"""
-        data_product_id = args.get("--dataProductId")
-        if not data_product_id:
-            return {"status": "error", "message": "dataProductId is required"}
-        
-        payload = self._get_payload_from_args(args)
-        endpoint = f"/dataproducts/{data_product_id}"
-        return self._make_request("PUT", endpoint, data=payload)
-
-    def dataProductDelete(self, args):
-        """Delete a data product"""
-        data_product_id = args.get("--dataProductId")
-        if not data_product_id:
-            return {"status": "error", "message": "dataProductId is required"}
-        
-        endpoint = f"/dataproducts/{data_product_id}"
-        return self._make_request("DELETE", endpoint)
-
-    # === GLOSSARY OPERATIONS ===
-
-    def glossaryTermsList(self, args):
-        """List glossary terms"""
-        params = {}
-        if args.get("--governanceDomain"):
-            params["domainId"] = args["--governanceDomain"]
-        
-        return self._make_request("GET", "/terms", params=params)
-
-    def glossaryTermCreate(self, args):
-        """Create a glossary term"""
-        payload = self._get_payload_from_args(args)
-        return self._make_request("POST", "/terms", data=payload)
-
-    def glossaryTermRead(self, args):
-        """Get a glossary term by ID"""
-        term_id = args.get("--termId")
-        if not term_id:
-            return {"status": "error", "message": "termId is required"}
-        
-        endpoint = f"/terms/{term_id}"
-        return self._make_request("GET", endpoint)
-
-    def glossaryTermUpdate(self, args):
-        """Update a glossary term"""
-        term_id = args.get("--termId")
-        if not term_id:
-            return {"status": "error", "message": "termId is required"}
-        
-        payload = self._get_payload_from_args(args)
-        endpoint = f"/terms/{term_id}"
-        return self._make_request("PUT", endpoint, data=payload)
-
-    def glossaryTermDelete(self, args):
-        """Delete a glossary term"""
-        term_id = args.get("--termId")
-        if not term_id:
-            return {"status": "error", "message": "termId is required"}
-        
-        endpoint = f"/terms/{term_id}"
-        return self._make_request("DELETE", endpoint)
-
-    # === BUSINESS DOMAIN OPERATIONS ===
-
-    def businessDomainsList(self, args):
-        """List business domains"""
-        return self._make_request("GET", "/businessdomains")
-
-    def businessDomainCreate(self, args):
-        """Create a business domain"""
-        payload = self._get_payload_from_args(args)
-        return self._make_request("POST", "/businessdomains", data=payload)
-
-    def businessDomainRead(self, args):
-        """Get a business domain by ID"""
-        domain_id = args.get("--domainId")
-        if not domain_id:
-            return {"status": "error", "message": "domainId is required"}
-        
-        endpoint = f"/businessdomains/{domain_id}"
-        return self._make_request("GET", endpoint)
-
-    def businessDomainUpdate(self, args):
-        """Update a business domain"""
-        domain_id = args.get("--domainId")
-        if not domain_id:
-            return {"status": "error", "message": "domainId is required"}
-        
-        payload = self._get_payload_from_args(args)
-        endpoint = f"/businessdomains/{domain_id}"
-        return self._make_request("PUT", endpoint, data=payload)
-
-    def businessDomainDelete(self, args):
-        """Delete a business domain"""
-        domain_id = args.get("--domainId")
-        if not domain_id:
-            return {"status": "error", "message": "domainId is required"}
-        
-        endpoint = f"/businessdomains/{domain_id}"
-        return self._make_request("DELETE", endpoint)
-
-    # === RELATIONSHIP OPERATIONS ===
-
-    def relationshipCreate(self, args):
-        """Create a relationship between entities"""
-        entity_type = args.get("--entityType")
-        entity_id = args.get("--entityId")
-        
-        if not entity_type or not entity_id:
-            return {"status": "error", "message": "entityType and entityId are required"}
-        
-        endpoint_map = {
-            "DataProduct": "dataproducts",
-            "Term": "terms",
-        }
-        
-        if entity_type not in endpoint_map:
-            return {"status": "error", "message": f"Unsupported entity type: {entity_type}"}
-        
-        endpoint = f"/{endpoint_map[entity_type]}/{entity_id}/relationships"
-        payload = self._get_payload_from_args(args)
-        params = {"entityType": entity_type}
-        
-        return self._make_request("POST", endpoint, data=payload, params=params)
-
-    def relationshipDelete(self, args):
-        """Delete a relationship between entities"""
-        entity_type = args.get("--entityType")
-        entity_id = args.get("--entityId")
-        target_entity_id = args.get("--targetEntityId")
-        relationship_type = args.get("--relationshipType")
-        
-        if not all([entity_type, entity_id, target_entity_id, relationship_type]):
-            return {"status": "error", "message": "entityType, entityId, targetEntityId, and relationshipType are required"}
-        
-        endpoint_map = {
-            "DataProduct": "dataproducts",
-            "Term": "terms",
+        """Initialize the Unified Catalog client."""
+        Endpoint.__init__(self)
+        self.app = "datagovernance"  # Use datagovernance app for UC endpoints
+
+    # ========================================
+    # GOVERNANCE DOMAINS
+    # ========================================
+    @decorator
+    def get_governance_domains(self, args):
+        """Get all governance domains."""
+        self.method = "GET"
+        self.endpoint = "/datagovernance/catalog/businessdomains"
+        self.params = {}
+
+    @decorator
+    def get_governance_domain_by_id(self, args):
+        """Get a governance domain by ID."""
+        domain_id = args.get("--domain-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/catalog/businessdomains/{domain_id}"
+        self.params = {}
+
+    @decorator
+    def create_governance_domain(self, args):
+        """Create a new governance domain."""
+        self.method = "POST"
+        self.endpoint = "/datagovernance/catalog/businessdomains"
+        self.payload = get_json(args, "--payloadFile") or {
+            "name": args.get("--name", [""])[0],
+            "description": args.get("--description", [""])[0],
+            "type": args.get("--type", ["FunctionalUnit"])[0],
+            "status": args.get("--status", ["Draft"])[0],
         }
-        
-        if entity_type not in endpoint_map:
-            return {"status": "error", "message": f"Unsupported entity type: {entity_type}"}
-        
-        endpoint = f"/{endpoint_map[entity_type]}/{entity_id}/relationships"
-        params = {
-            "entityId": target_entity_id,
-            "entityType": entity_type,
-            "relationshipType": relationship_type
+
+    @decorator
+    def update_governance_domain(self, args):
+        """Update a governance domain."""
+        domain_id = args.get("--domain-id", [""])[0]
+        self.method = "PUT"
+        self.endpoint = f"/datagovernance/catalog/businessdomains/{domain_id}"
+        self.payload = get_json(args, "--payloadFile") or {
+            "name": args.get("--name", [""])[0],
+            "description": args.get("--description", [""])[0],
+            "type": args.get("--type", [""])[0],
+            "status": args.get("--status", [""])[0],
         }
-        
-        return self._make_request("DELETE", endpoint, params=params)
-
-    # === HELPER METHODS ===
-
-    def _get_payload_from_args(self, args):
-        """Extract payload from args, either from --payloadFile or construct from individual args"""
-        if args.get("--payloadFile"):
-            # Load from file
-            with open(args["--payloadFile"], 'r') as f:
-                return json.load(f)
-        
-        # Construct from individual arguments
-        payload = {}
-        
-        # Common fields
-        if args.get("--name"):
-            payload["name"] = args["--name"]
-        if args.get("--description"):
-            payload["description"] = args["--description"]
-        if args.get("--governanceDomain"):
-            payload["domain"] = args["--governanceDomain"]
-        if args.get("--type"):
-            payload["type"] = args["--type"]
-        if args.get("--businessUse"):
-            payload["businessUse"] = args["--businessUse"]
+
+    @decorator
+    def delete_governance_domain(self, args):
+        """Delete a governance domain."""
+        domain_id = args.get("--domain-id", [""])[0]
+        self.method = "DELETE"
+        self.endpoint = f"/datagovernance/catalog/businessdomains/{domain_id}"
+        self.params = {}
+
+    # ========================================
+    # DATA PRODUCTS
+    # ========================================
+    @decorator
+    def get_data_products(self, args):
+        """Get all data products."""
+        self.method = "GET"
+        self.endpoint = "/datagovernance/dataProducts"
+        self.params = {}
+
+        # Add optional filters
+        if args.get("--domain-id"):
+            self.params["domainId"] = args["--domain-id"][0]
         if args.get("--status"):
-            payload["status"] = args["--status"]
-        if args.get("--endorsed"):
-            payload["endorsed"] = args["--endorsed"] == "true"
-        
-        # Relationships
-        if args.get("--entityId"):
-            payload["entityId"] = args["--entityId"]
-        if args.get("--relationshipType"):
-            payload["relationshipType"] = args["--relationshipType"]
-        
-        return payload
-
-    # === HIGH-LEVEL CONVENIENCE METHODS ===
-    # These methods provide a simpler interface for common operations
-
-    def create_data_product(self, name, description=None, domain_guid=None):
-        """Create a data product with simple parameters"""
-        args = {
-            "--name": name,
-            "--description": description or "",
-            "--governanceDomain": domain_guid,
-            "--type": "Dataset",  # Default type
-            "--status": "Draft"   # Default status
+            self.params["status"] = args["--status"][0]
+
+    @decorator
+    def get_data_product_by_id(self, args):
+        """Get a data product by ID."""
+        product_id = args.get("--product-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/dataProducts/{product_id}"
+        self.params = {}
+
+    @decorator
+    def create_data_product(self, args):
+        """Create a new data product."""
+        self.method = "POST"
+        self.endpoint = "/datagovernance/dataProducts"
+        self.payload = get_json(args, "--payloadFile") or {
+            "name": args.get("--name", [""])[0],
+            "description": args.get("--description", [""])[0],
+            "domainId": args.get("--domain-id", [""])[0],
+            "status": args.get("--status", ["Draft"])[0],
         }
-        return self.dataProductCreate(args)
-
-    def get_data_product(self, data_product_id):
-        """Get a data product by ID"""
-        args = {"--dataProductId": data_product_id}
-        return self.dataProductRead(args)
-
-    def update_data_product(self, data_product_id, updates):
-        """Update a data product with a dictionary of updates"""
-        args = {"--dataProductId": data_product_id}
-        args.update({f"--{k}": v for k, v in updates.items()})
-        return self.dataProductUpdate(args)
-
-    def delete_data_product(self, data_product_id):
-        """Delete a data product by ID"""
-        args = {"--dataProductId": data_product_id}
-        return self.dataProductDelete(args)
-
-    def list_data_products(self, limit=50, offset=0, domain_id=None):
-        """List data products with pagination"""
-        args = {
-            "--limit": str(limit),
-            "--skip": str(offset)
+
+    @decorator
+    def update_data_product(self, args):
+        """Update a data product."""
+        product_id = args.get("--product-id", [""])[0]
+        self.method = "PUT"
+        self.endpoint = f"/datagovernance/dataProducts/{product_id}"
+        self.payload = get_json(args, "--payloadFile") or {
+            "name": args.get("--name", [""])[0],
+            "description": args.get("--description", [""])[0],
+            "domainId": args.get("--domain-id", [""])[0],
+            "status": args.get("--status", [""])[0],
         }
-        if domain_id:
-            args["--governanceDomain"] = domain_id
-        return self.dataProductList(args)
-
-    def create_glossary_term(self, name, description, domain_id):
-        """Create a glossary term"""
-        args = {
-            "--name": name,
-            "--description": description,
-            "--governanceDomain": domain_id,
-            "--status": "Draft"
+
+    @decorator
+    def delete_data_product(self, args):
+        """Delete a data product."""
+        product_id = args.get("--product-id", [""])[0]
+        self.method = "DELETE"
+        self.endpoint = f"/datagovernance/dataProducts/{product_id}"
+        self.params = {}
+
+    # ========================================
+    # GLOSSARY TERMS
+    # ========================================
+
+    @decorator
+    def get_terms(self, args):
+        """Get all glossary terms in a governance domain."""
+        domain_id = args.get("--governance-domain-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/catalog/businessdomains/{domain_id}/glossaryterms"
+        self.params = {}
+
+    @decorator
+    def get_term_by_id(self, args):
+        """Get a glossary term by ID."""
+        term_id = args.get("--term-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/catalog/glossaryterms/{term_id}"
+        self.params = {}
+
+    @decorator
+    def create_term(self, args):
+        """Create a new glossary term."""
+        self.method = "POST"
+        self.endpoint = "/datagovernance/catalog/glossaryterms"
+
+        # Build payload
+        payload = {
+            "name": args.get("--name", [""])[0],
+            "description": args.get("--description", [""])[0],
+            "governanceDomainId": args.get("--governance-domain-id", [""])[0],
+            "status": args.get("--status", ["Draft"])[0],
         }
-        return self.glossaryTermCreate(args)
-
-    def link_term_to_data_product(self, data_product_id, term_id):
-        """Link a glossary term to a data product"""
-        args = {
-            "--entityType": "DataProduct",
-            "--entityId": data_product_id,
-            "--entityId": term_id,
-            "--relationshipType": "Related"
+
+        # Add optional fields
+        if args.get("--acronyms"):
+            payload["acronyms"] = args["--acronyms"]
+        if args.get("--owner-id"):
+            payload["ownerIds"] = args["--owner-id"]
+        if args.get("--resource-name") and args.get("--resource-url"):
+            payload["resources"] = [
+                {"name": args["--resource-name"][0], "url": args["--resource-url"][0]}
+            ]
+
+        self.payload = payload
+
+    # ========================================
+    # OBJECTIVES AND KEY RESULTS (OKRs)
+    # ========================================
+
+    @decorator
+    def get_objectives(self, args):
+        """Get all objectives in a governance domain."""
+        domain_id = args.get("--governance-domain-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/catalog/businessdomains/{domain_id}/objectives"
+        self.params = {}
+
+    @decorator
+    def get_objective_by_id(self, args):
+        """Get an objective by ID."""
+        objective_id = args.get("--objective-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/catalog/objectives/{objective_id}"
+        self.params = {}
+
+    @decorator
+    def create_objective(self, args):
+        """Create a new objective."""
+        self.method = "POST"
+        self.endpoint = "/datagovernance/catalog/objectives"
+
+        payload = {
+            "definition": args.get("--definition", [""])[0],
+            "governanceDomainId": args.get("--governance-domain-id", [""])[0],
+            "status": args.get("--status", ["Draft"])[0],
         }
-        return self.relationshipCreate(args)
+
+        if args.get("--owner-id"):
+            payload["ownerIds"] = args["--owner-id"]
+        if args.get("--target-date"):
+            payload["targetDate"] = args["--target-date"][0]
+
+        self.payload = payload
+
+    # ========================================
+    # CRITICAL DATA ELEMENTS (CDEs)
+    # ========================================
+
+    @decorator
+    def get_critical_data_elements(self, args):
+        """Get all critical data elements in a governance domain."""
+        domain_id = args.get("--governance-domain-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/catalog/businessdomains/{domain_id}/criticaldataelements"
+        self.params = {}
+
+    @decorator
+    def get_critical_data_element_by_id(self, args):
+        """Get a critical data element by ID."""
+        cde_id = args.get("--cde-id", [""])[0]
+        self.method = "GET"
+        self.endpoint = f"/datagovernance/catalog/criticaldataelements/{cde_id}"
+        self.params = {}
+
+    @decorator
+    def create_critical_data_element(self, args):
+        """Create a new critical data element."""
+        self.method = "POST"
+        self.endpoint = "/datagovernance/catalog/criticaldataelements"
+
+        payload = {
+            "name": args.get("--name", [""])[0],
+            "description": args.get("--description", [""])[0],
+            "governanceDomainId": args.get("--governance-domain-id", [""])[0],
+            "dataType": args.get("--data-type", ["String"])[0],
+            "status": args.get("--status", ["Draft"])[0],
+        }
+
+        if args.get("--owner-id"):
+            payload["ownerIds"] = args["--owner-id"]
+
+        self.payload = payload
+
+    # ========================================
+    # UTILITY METHODS
+    # ========================================
+
+    @no_api_call_decorator
+    def help(self, args):
+        """Display help information for Unified Catalog operations."""
+        help_text = """
+Microsoft Purview Unified Catalog Client
+
+Available Operations:
+- Governance Domains: list, get, create, update, delete
+- Data Products: list, get, create, update, delete
+- Glossary Terms: list, get, create
+- Objectives (OKRs): list, get, create  
+- Critical Data Elements: list, get, create
+
+Use --payloadFile to provide JSON payload for create/update operations.
+Use individual flags like --name, --description for simple operations.
+"""
+        return {"message": help_text}