- ['sdk/purview/azure-purview-account/swagger/README.md', '#4554']

"azure-purview-account",

- This is the initial release of the Azure Purview Account library.

recursive-include tests *.py

recursive-include samples *.py *.md

include *.md

include azure/__init__.py

include azure/purview/__init__.py

Azure Purview Account is a fully managed cloud service.

**Please rely heavily on the [service's documentation][account_product_documentation] and our [client docs][request_builders_and_client] to use this library**

[Source code][source_code] | [Package (PyPI)][account_pypi] | [API reference documentation][account_ref_docs]| [Product documentation][account_product_documentation]

- Python 2.7, or 3.6 or later is required to use this package.

- You must have an [Azure subscription][azure_subscription] and a [Purview][purview_resource] to use this package.

Follow [these][purview_resource] instructions to create your Purview resource

Install the Azure Purview Account client library for Python with [pip][pip]:

pip install azure-purview-account

To use an [Azure Active Directory (AAD) token credential][authenticate_with_token],

provide an instance of the desired credential type obtained from the

[azure-identity][azure_identity_credentials] library.

To authenticate with AAD, you must first [pip][pip] install [`azure-identity`][azure_identity_pip] and

[enable AAD authentication on your Purview resource][enable_aad]

After setup, you can choose which type of [credential][azure_identity_credentials] from azure.identity to use.

As an example, [DefaultAzureCredential][default_azure_credential]

can be used to authenticate the client:

Set the values of the client ID, tenant ID, and client secret of the AAD application as environment variables:

AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET

Use the returned token credential to authenticate the client:

from azure.purview.account import PurviewAccountClient

from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

client = PurviewAccountClient(endpoint="https://<my-account-name>.purview.azure.com", credential=credential)

The following section shows you how to initialize and authenticate your client, then list all of your keys.

- [Get Keys](#get-keys "Get All Keys")

from azure.purview.account import PurviewAccountClient

from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

client = PurviewAccountClient(endpoint="https://<my-account-name>.purview.azure.com", credential=credential)

response = client.accounts.get_access_keys()

print(response)

The Purview Account client will raise exceptions if status code of your responses is not defined.

This library uses the standard

[logging][python_logging] library for logging.

Basic information about HTTP sessions (URLs, headers, etc.) is logged at INFO

level.

Detailed DEBUG level logging, including request/response bodies and unredacted

headers, can be enabled on a client with the `logging_enable` keyword argument:

import sys

import logging

from azure.identity import DefaultAzureCredential

from azure.purview.account import PurviewAccountClient

logger = logging.getLogger('azure')

logger.setLevel(logging.DEBUG)

handler = logging.StreamHandler(stream=sys.stdout)

logger.addHandler(handler)

endpoint = "https://<my-account-name>.purview.azure.com"

credential = DefaultAzureCredential()

client = PurviewAccountClient(endpoint=endpoint, credential=credential, logging_enable=True)

Similarly, `logging_enable` can enable detailed logging for a single call,

even when it isn't enabled for the client:

result = client.accounts.get_access_keys(logging_enable=True)

For more generic samples, see our [client docs][request_builders_and_client].

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit [cla.microsoft.com][cla].

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the [Microsoft Open Source Code of Conduct][code_of_conduct]. For more information see the [Code of Conduct FAQ][coc_faq] or contact [opencode@microsoft.com][coc_contact] with any additional questions or comments.

[source_code]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/purview/

[account_pypi]: https://pypi.org/project/azure-purview-catalog/#history

[account_ref_docs]: https://azure.github.io/azure-sdk-for-python/

[account_product_documentation]: https://azure.microsoft.com/services/purview/

[azure_subscription]: https://azure.microsoft.com/free/

[purview_resource]: https://docs.microsoft.com/azure/purview/create-catalog-portal

[pip]: https://pypi.org/project/pip/

[authenticate_with_token]: https://docs.microsoft.com/azure/cognitive-services/authentication?tabs=powershell#authenticate-with-an-authentication-token

[azure_identity_credentials]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#credentials

[azure_identity_pip]: https://pypi.org/project/azure-identity/

[default_azure_credential]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#defaultazurecredential

[request_builders_and_client]: https://aka.ms/azsdk/python/protocol/quickstart

[enable_aad]: https://docs.microsoft.com/azure/purview/create-catalog-portal#add-a-security-principal-to-a-data-plane-role

[python_logging]: https://docs.python.org/3.5/library/logging.html

[cla]: https://cla.microsoft.com

[code_of_conduct]: https://opensource.microsoft.com/codeofconduct/

[coc_faq]: https://opensource.microsoft.com/codeofconduct/faq/

[coc_contact]: mailto:opencode@microsoft.com

__path__ = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore

__path__ = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore

from ._purview_account_client import PurviewAccountClient

from ._version import VERSION

__version__ = VERSION

__all__ = ['PurviewAccountClient']

try:

from ._patch import patch_sdk # type: ignore

patch_sdk()

except ImportError:

pass

from typing import TYPE_CHECKING

from azure.core.configuration import Configuration

from azure.core.pipeline import policies

from ._version import VERSION

if TYPE_CHECKING:

# pylint: disable=unused-import,ungrouped-imports

from typing import Any

from azure.core.credentials import TokenCredential

class PurviewAccountClientConfiguration(Configuration):

"""Configuration for PurviewAccountClient.

def __init__(

self,

endpoint, # type: str

credential, # type: "TokenCredential"

**kwargs # type: Any

):

# type: (...) -> None

if endpoint is None:

raise ValueError("Parameter 'endpoint' must not be None.")

if credential is None:

raise ValueError("Parameter 'credential' must not be None.")

super(PurviewAccountClientConfiguration, self).__init__(**kwargs)

self.endpoint = endpoint

self.credential = credential

self.api_version = "2019-11-01-preview"

self.credential_scopes = kwargs.pop('credential_scopes', ['https://purview.azure.net/.default'])

kwargs.setdefault('sdk_moniker', 'purview-account/{}'.format(VERSION))

self._configure(**kwargs)

def _configure(

self,

**kwargs # type: Any

):

# type: (...) -> None

self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)

self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)

self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)

self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)

self.http_logging_policy = kwargs.get('http_logging_policy') or policies.HttpLoggingPolicy(**kwargs)

self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs)

self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)

self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs)

self.authentication_policy = kwargs.get('authentication_policy')

if self.credential and not self.authentication_policy:

self.authentication_policy = policies.BearerTokenCredentialPolicy(self.credential, *self.credential_scopes, **kwargs)

from copy import deepcopy

from typing import TYPE_CHECKING

from azure.core import PipelineClient

from msrest import Deserializer, Serializer

from ._configuration import PurviewAccountClientConfiguration

from .operations import AccountsOperations, CollectionsOperations, ResourceSetRulesOperations

if TYPE_CHECKING:

# pylint: disable=unused-import,ungrouped-imports

from typing import Any, Dict, Optional

from azure.core.credentials import TokenCredential

from azure.core.rest import HttpRequest, HttpResponse

class PurviewAccountClient(object):

"""Creates a Microsoft.Purview data plane account client.

def __init__(

self,

endpoint, # type: str

credential, # type: "TokenCredential"

**kwargs # type: Any

):

# type: (...) -> None

_endpoint = '{endpoint}'

self._config = PurviewAccountClientConfiguration(endpoint, credential, **kwargs)

self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs)

self._serialize = Serializer()

self._deserialize = Deserializer()

self._serialize.client_side_validation = False

self.accounts = AccountsOperations(self._client, self._config, self._serialize, self._deserialize)

self.collections = CollectionsOperations(self._client, self._config, self._serialize, self._deserialize)

self.resource_set_rules = ResourceSetRulesOperations(self._client, self._config, self._serialize, self._deserialize)

def send_request(

self,

request, # type: HttpRequest

**kwargs # type: Any

):

# type: (...) -> HttpResponse

"""Runs the network request through the client's chained policies.

request_copy = deepcopy(request)

path_format_arguments = {

"endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),

}

request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)

return self._client.send_request(request_copy, **kwargs)

def close(self):

# type: () -> None

self._client.close()

def __enter__(self):

# type: () -> PurviewAccountClient

self._client.__enter__()

return self

def __exit__(self, *exc_details):

# type: (Any) -> None

self._client.__exit__(*exc_details)

VERSION = "1.0.0b1"