[SchemaRegistry] update client for JSON/Custom GA (#36386)

* remove JsonSchemaDraftIdentifier

* address apiview comments/remove protobuf

* revert sample

* mypy/pylint

* rename MessageType + black

* re-gen for api version 2022-10

* readme + changelog

* update test recordings for api_version 2022-10

* update version

Author: swathipil

sdk/schemaregistry/azure-schemaregistry/CHANGELOG.md

@@ -1,22 +1,34 @@
 # Release History
 
-## 1.3.0b4 (Unreleased)
+## 1.3.0 (Unreleased)
+
+This version and all future versions will require Python 3.8+. Python 3.7 is no longer supported.
 
 ### Features Added
 
-### Breaking Changes
+- `V2022_10` has been added to `ApiVersion` and set as the default API version.
+  - `Json` and `Custom` have been added to supported formats in `SchemaFormat`.
+- Sync and async `JsonSchemaEncoder` have been added under `azure.schemaregistry.encoder.jsonencoder`.
+- `InvalidContentError` have been added under `azure.schemaregistry.encoder.jsonencoder` for use with the `JsonSchemaEncoder`.
+- `MessageContent`, `OutboundMessageContent`,`InboundMessageContent`, and `SchemaContentValidate` have been added under `azure.schemaregistry` as protocols for use with the `JsonSchemaEncoder` and/or future encoder implementations.
 
 ### Bugs Fixed
 
+- Fixed a bug in sync/async `register_schema` and `get_schema_properties` that did not accept case insensitive strings as an argument to the `format` parameter.
+
 ### Other Changes
 
 - Updated azure-core minimum dependency to 1.28.0.
+- Added support for Python 3.11 and 3.12.
+- The following features have been temporarily pulled out and will be added back in future previews as we work towards a stable release:
+  - `V2023_07_01` in `ApiVersion`.
+    - `PROTOBUF` in `SchemaFormat`.
 
 ## 1.3.0b3 (2023-11-09)
 
 ### Features Added
 
-- `V2023_07_01` has been added to `ApiVersion` and set as the default api version.
+- `V2023_07_01` has been added to `ApiVersion` and set as the default API version.
   - `Protobuf` has been added to supported formats in `SchemaFormat`.
 
 ### Other Changes

sdk/schemaregistry/azure-schemaregistry/README.md

@@ -27,20 +27,20 @@ _Azure SDK Python packages support for Python 2.7 has ended on 01 January 2022.
 Install the Azure Schema Registry client library for Python with [pip][pip]:
 
 ```Bash
-pip install azure-schemaregistry==1.3.0b2
+pip install azure-schemaregistry
 ```
 
 To use the built-in `jsonschema` validators with the JSON Schema Encoder, install `jsonencoder` extras:
 
 ```Bash
-pip install azure-schemaregistry[jsonencoder]==1.3.0b2
+pip install azure-schemaregistry[jsonencoder]
 ```
 
 ### Prerequisites:
 To use this package, you must have:
 * Azure subscription - [Create a free account][azure_sub]
 * [Azure Schema Registry][schemaregistry_service] - [Here is the quickstart guide][quickstart_guide] to create a Schema Registry group using the Azure portal.
-* Python 3.7 or later - [Install Python][python]
+* Python 3.8 or later - [Install Python][python]
 
 ### Authenticate the client
 
@@ -91,20 +91,27 @@ encoder = JsonSchemaEncoder(client=schema_registry_client, group_name=group_name
 
 ## Key concepts
 
+### Client concepts
+
 * Schema: Schema is the organization or structure for data. More detailed information can be found [here][schemas].
 
 * Schema Group: A logical group of similar schemas based on business criteria, which can hold multiple versions of a schema. More detailed information can be found [here][schema_groups].
 
 * SchemaRegistryClient: `SchemaRegistryClient` provides the API for storing and retrieving schemas in schema registry.
 
+### Encoder concepts
+
 * JsonSchemaEncoder: Provides API to encode content to and decode content from Binary Encoding, validate content against a JSON Schema, and cache schemas/schema IDs retrived from the registry using the `SchemaRegistryClient` locally.
 
-* MessageType: Protocol defined under `azure.schemaregistry` that allows for `JsonSchemaEncoder` interoperability with certain Azure Messaging SDK message types. Support has been added to:
+* OutboundMessageContent: Protocol defined under `azure.schemaregistry` that allows for `JsonSchemaEncoder.encode` interoperability with certain Azure Messaging SDK message types. Support has been added to:
+  * `azure.eventhub.EventData` for `azure-eventhub>=5.9.0`
+
+* InboundMessageContent: Protocol defined under `azure.schemaregistry` that allows for `JsonSchemaEncoder.decode` interoperability with certain Azure Messaging SDK message types. Support has been added to:
   * `azure.eventhub.EventData` for `azure-eventhub>=5.9.0`
 
-### MessageType
+#### OutboundMessageContent/InboundMessageContent
 
-If a message type that follows the MessageType protocol is provided to the encoder, it will set the corresponding content and content type properties:
+If a message type that follows the OutboundMessageContent protocol is provided to the `JsonSchemaEncoder`, it will set the corresponding content and content type properties. If a message type object that follows the InboundMessageContent protocol is provided to the encoder, it will get the corresponding content and content type properties. These are defined as:
 
 * `content`: Binary-encoded, JSON schema-validated payload (in general, format-specific payload)
 
@@ -253,15 +260,17 @@ The `encode` method automatically retrieves the schema from the Schema Registry
 
 ```python
 import os
+import json
 from azure.schemaregistry import SchemaRegistryClient, SchemaFormat
-from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder, JsonSchemaDraftIdentifier
+from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder
 from azure.identity import DefaultAzureCredential
 from azure.eventhub import EventData
 
 token_credential = DefaultAzureCredential()
 fully_qualified_namespace = os.environ['SCHEMAREGISTRY_JSON_FULLY_QUALIFIED_NAMESPACE']
 group_name = os.environ['SCHEMAREGISTRY_GROUP']
 format = SchemaFormat.JSON
+DRAFT2020_12_SCHEMA_IDENTIFIER = "https://json-schema.org/draft/2020-12/schema"
 
 schema = {
     "$id": "https://example.com/person.schema.json",
@@ -291,7 +300,7 @@ schema_properties = schema_registry_client.register_schema(group_name, name, def
 schema_id = schema_properties.id
 
 # group_name only needed if passing `schema` to encode
-encoder = JsonSchemaEncoder(client=schema_registry_client, validate=JsonSchemaDraftIdentifier.DRAFT2020_12, group_name=group_name)
+encoder = JsonSchemaEncoder(client=schema_registry_client, validate=DRAFT2020_12_SCHEMA_IDENTIFIER, group_name=group_name)
 
 with encoder:
     dict_content = {"name": "Ben", "favorite_number": 7, "favorite_color": "red"}
@@ -317,15 +326,16 @@ The `decode` method automatically retrieves the schema from the Schema Registry
 ```python
 import os
 from azure.schemaregistry import SchemaRegistryClient
-from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder, JsonSchemaDraftIdentifier
+from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder
 from azure.identity import DefaultAzureCredential
 
 token_credential = DefaultAzureCredential()
 fully_qualified_namespace = os.environ['SCHEMAREGISTRY_FULLY_QUALIFIED_NAMESPACE']
 group_name = os.environ["SCHEMAREGISTRY_GROUP"]
+DRAFT2020_12_SCHEMA_IDENTIFIER = "https://json-schema.org/draft/2020-12/schema"
 
 schema_registry_client = SchemaRegistryClient(fully_qualified_namespace, token_credential)
-encoder = JsonSchemaEncoder(client=schema_registry_client, validate=JsonSchemaDraftIdentifier.DRAFT2020_12)
+encoder = JsonSchemaEncoder(client=schema_registry_client, validate=DRAFT2020_12_SCHEMA_IDENTIFIER)
 
 with encoder:
     # event_data is an EventData object with encoded body
@@ -345,7 +355,7 @@ Integration with [Event Hubs][eventhubs_repo] to send an `EventData` object with
 import os
 from azure.eventhub import EventHubProducerClient, EventData
 from azure.schemaregistry import SchemaRegistryClient
-from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder, JsonSchemaDraftIdentifier
+from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder
 from azure.identity import DefaultAzureCredential
 
 token_credential = DefaultAzureCredential()
@@ -355,9 +365,10 @@ eventhub_connection_str = os.environ['EVENT_HUB_CONN_STR']
 eventhub_name = os.environ['EVENT_HUB_NAME']
 
 schema_id = os.environ['PERSON_JSON_SCHEMA_ID']
+DRAFT2020_12_SCHEMA_IDENTIFIER = "https://json-schema.org/draft/2020-12/schema"
 
 schema_registry_client = SchemaRegistryClient(fully_qualified_namespace, token_credential)
-json_schema_encoder = JsonSchemaEncoder(client=schema_registry_client, validate=JsonSchemaDraftIdentifier.DRAFT2020_12)
+json_schema_encoder = JsonSchemaEncoder(client=schema_registry_client, validate=DRAFT2020_12_SCHEMA_IDENTIFIER)
 
 eventhub_producer = EventHubProducerClient.from_connection_string(
     conn_str=eventhub_connection_str,
@@ -380,17 +391,18 @@ Integration with [Event Hubs][eventhubs_repo] to receive an `EventData` object a
 import os
 from azure.eventhub import EventHubConsumerClient
 from azure.schemaregistry import SchemaRegistryClient
-from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder, JsonSchemaDraftIdentifier
+from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder
 from azure.identity import DefaultAzureCredential
 
 token_credential = DefaultAzureCredential()
-fully_qualified_namespace = os.environ['SCHEMAREGISTRY_FULLY_QUALIFIED_NAMESPACE']
+fully_qualified_namespace = os.environ['SCHEMAREGISTRY_JSON_FULLY_QUALIFIED_NAMESPACE']
 group_name = os.environ['SCHEMAREGISTRY_GROUP']
 eventhub_connection_str = os.environ['EVENT_HUB_CONN_STR']
 eventhub_name = os.environ['EVENT_HUB_NAME']
+DRAFT2020_12_SCHEMA_IDENTIFIER = "https://json-schema.org/draft/2020-12/schema"
 
 schema_registry_client = SchemaRegistryClient(fully_qualified_namespace, token_credential)
-json_schema_encoder = JsonSchemaEncoder(client=schema_registry_client, validate=JsonSchemaDraftIdentifier.DRAFT2020_12)
+json_schema_encoder = JsonSchemaEncoder(client=schema_registry_client, validate=DRAFT2020_12_SCHEMA_IDENTIFIER)
 
 eventhub_consumer = EventHubConsumerClient.from_connection_string(
     conn_str=eventhub_connection_str,
@@ -427,7 +439,7 @@ import sys
 import os
 import logging
 from azure.schemaregistry import SchemaRegistryClient
-from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder, JsonSchemaDraftIdentifier
+from azure.schemaregistry.encoder.jsonencoder import JsonSchemaEncoder
 from azure.identity import DefaultAzureCredential
 
 # Create a logger for the SDK
@@ -440,10 +452,11 @@ logger.addHandler(handler)
 
 fully_qualified_namespace = os.environ['SCHEMAREGISTRY_FULLY_QUALIFIED_NAMESPACE']
 group_name = os.environ['SCHEMAREGISTRY_GROUP']
+DRAFT2020_12_SCHEMA_IDENTIFIER = "https://json-schema.org/draft/2020-12/schema"
 credential = DefaultAzureCredential()
 # This client will log detailed information about its HTTP sessions, at DEBUG level
 schema_registry_client = SchemaRegistryClient(fully_qualified_namespace, credential, logging_enable=True)
-encoder = JsonSchemaEncoder(client=schema_registry_client, validate=JsonSchemaDraftIdentifier.DRAFT2020_12)
+encoder = JsonSchemaEncoder(client=schema_registry_client, validate=DRAFT2020_12_SCHEMA_IDENTIFIER)
 ```
 
 Similarly, `logging_enable` can enable detailed logging for a single operation,

sdk/schemaregistry/azure-schemaregistry/assets.json

@@ -2,5 +2,5 @@
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "python",
   "TagPrefix": "python/schemaregistry/azure-schemaregistry",
-  "Tag": "python/schemaregistry/azure-schemaregistry_88eea61cd4"
+  "Tag": "python/schemaregistry/azure-schemaregistry_a1c9d18bfd"
 }

sdk/schemaregistry/azure-schemaregistry/azure/schemaregistry/_client.py

@@ -32,7 +32,7 @@ class SchemaRegistryClient(SchemaRegistryClientOperationsMixin):  # pylint: disa
     :type fully_qualified_namespace: str
     :param credential: Credential used to authenticate requests to the service. Required.
     :type credential: ~azure.core.credentials.TokenCredential
-    :keyword api_version: The API version to use for this operation. Default value is "2023-07-01".
+    :keyword api_version: The API version to use for this operation. Default value is "2022-10".
      Note that overriding this default value may result in unsupported behavior.
     :paramtype api_version: str
     """

sdk/schemaregistry/azure-schemaregistry/azure/schemaregistry/_configuration.py

@@ -28,13 +28,13 @@ class SchemaRegistryClientConfiguration:  # pylint: disable=too-many-instance-at
     :type fully_qualified_namespace: str
     :param credential: Credential used to authenticate requests to the service. Required.
     :type credential: ~azure.core.credentials.TokenCredential
-    :keyword api_version: The API version to use for this operation. Default value is "2023-07-01".
+    :keyword api_version: The API version to use for this operation. Default value is "2022-10".
      Note that overriding this default value may result in unsupported behavior.
     :paramtype api_version: str
     """
 
     def __init__(self, fully_qualified_namespace: str, credential: "TokenCredential", **kwargs: Any) -> None:
-        api_version: str = kwargs.pop("api_version", "2023-07-01")
+        api_version: str = kwargs.pop("api_version", "2022-10")
 
         if fully_qualified_namespace is None:
             raise ValueError("Parameter 'fully_qualified_namespace' must not be None.")

sdk/schemaregistry/azure-schemaregistry/azure/schemaregistry/_operations/_operations.py

@@ -43,7 +43,7 @@ def build_schema_registry_list_schema_groups_request(**kwargs: Any) -> HttpReque
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-10"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
@@ -64,7 +64,7 @@ def build_schema_registry_list_schema_versions_request(  # pylint: disable=name-
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-10"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
@@ -91,7 +91,7 @@ def build_schema_registry_get_schema_by_id_request(  # pylint: disable=name-too-
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-10"))
     accept = _headers.pop("Accept", "application/json; serialization=Avro")
     # Construct URL
     _url = "/$schemaGroups/$schemas/{id}"
@@ -116,7 +116,7 @@ def build_schema_registry_get_schema_by_version_request(  # pylint: disable=name
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-10"))
     accept = _headers.pop("Accept", "application/json; serialization=Avro")
     # Construct URL
     _url = "/$schemaGroups/{groupName}/schemas/{schemaName}/versions/{schemaVersion}"

sdk/schemaregistry/azure-schemaregistry/azure/schemaregistry/_operations/_patch.py

@@ -20,7 +20,10 @@
 from azure.core.utils import case_insensitive_dict
 from azure.core.tracing.decorator import distributed_trace
 
-from ._operations import ClsType, SchemaRegistryClientOperationsMixin as GeneratedClientOperationsMixin
+from ._operations import (
+    ClsType,
+    SchemaRegistryClientOperationsMixin as GeneratedClientOperationsMixin,
+)
 from .._serialization import Serializer
 
 if TYPE_CHECKING:
@@ -143,7 +146,10 @@ def _get_schema_properties_by_content(  # pylint: disable=inconsistent-return-st
         )
         path_format_arguments = {
             "fullyQualifiedNamespace": self._serialize.url(
-                "self._config.fully_qualified_namespace", self._config.fully_qualified_namespace, "str", skip_quote=True
+                "self._config.fully_qualified_namespace",
+                self._config.fully_qualified_namespace,
+                "str",
+                skip_quote=True,
             ),
         }
         request.url = self._client.format_url(request.url, **path_format_arguments)
@@ -224,7 +230,10 @@ def _register_schema(  # pylint: disable=inconsistent-return-statements
         )
         path_format_arguments = {
             "fullyQualifiedNamespace": self._serialize.url(
-                "self._config.fully_qualified_namespace", self._config.fully_qualified_namespace, "str", skip_quote=True
+                "self._config.fully_qualified_namespace",
+                self._config.fully_qualified_namespace,
+                "str",
+                skip_quote=True,
             ),
         }
         request.url = self._client.format_url(request.url, **path_format_arguments)