chore: resync generator on latest API commit

changes:
- No changes to the client interface
- API changes include support for write conflict options

API commit: 0ac19aac54f21f3c78970126b84b4c69c6e3b9a2

Author: rhamzeh

.openapi-generator/FILES

@@ -253,8 +253,6 @@ openfga_sdk/telemetry/metrics.py
 openfga_sdk/telemetry/telemetry.py
 openfga_sdk/validation.py
 pyproject.toml
-README.md
-test/__init__.py
 test/_/configuration_test.py
 test/_/credentials_test.py
 test/_/oauth2_test.py

docs/OpenFgaApi.md

@@ -1291,7 +1291,7 @@ No authorization required
 
 Add or delete tuples from the store
 
-The Write API will transactionally update the tuples for a certain store. Tuples and type definitions allow OpenFGA to determine whether a relationship exists between an object and an user. In the body, `writes` adds new tuples and `deletes` removes existing tuples. When deleting a tuple, any `condition` specified with it is ignored. The API is not idempotent: if, later on, you try to add the same tuple key (even if the `condition` is different), or if you try to delete a non-existing tuple, it will throw an error. The API will not allow you to write tuples such as `document:2021-budget#viewer@document:2021-budget#viewer`, because they are implicit. An `authorization_model_id` may be specified in the body. If it is, it will be used to assert that each written tuple (not deleted) is valid for the model specified. If it is not specified, the latest authorization model ID will be used. ## Example ### Adding relationships To add `user:anne` as a `writer` for `document:2021-budget`, call write API with the following  ```json {   \"writes\": {     \"tuple_keys\": [       {         \"user\": \"user:anne\",         \"relation\": \"writer\",         \"object\": \"document:2021-budget\"       }     ]   },   \"authorization_model_id\": \"01G50QVV17PECNVAHX1GG4Y5NC\" } ``` ### Removing relationships To remove `user:bob` as a `reader` for `document:2021-budget`, call write API with the following  ```json {   \"deletes\": {     \"tuple_keys\": [       {         \"user\": \"user:bob\",         \"relation\": \"reader\",         \"object\": \"document:2021-budget\"       }     ]   } } ``` 
+The Write API will transactionally update the tuples for a certain store. Tuples and type definitions allow OpenFGA to determine whether a relationship exists between an object and an user. In the body, `writes` adds new tuples and `deletes` removes existing tuples. When deleting a tuple, any `condition` specified with it is ignored. The API is not idempotent by default: if, later on, you try to add the same tuple key (even if the `condition` is different), or if you try to delete a non-existing tuple, it will throw an error. To allow writes when an identical tuple already exists in the database, set `\"on_duplicate\": \"ignore\"` on the `writes` object. To allow deletes when a tuple was already removed from the database, set `\"on_missing\": \"ignore\"` on the `deletes` object. If a Write request contains both idempotent (ignore) and non-idempotent (error) operations, the most restrictive action (error) will take precedence. If a condition fails for a sub-request with an error flag, the entire transaction will be rolled back. This gives developers explicit control over the atomicity of the requests. The API will not allow you to write tuples such as `document:2021-budget#viewer@document:2021-budget#viewer`, because they are implicit. An `authorization_model_id` may be specified in the body. If it is, it will be used to assert that each written tuple (not deleted) is valid for the model specified. If it is not specified, the latest authorization model ID will be used. ## Example ### Adding relationships To add `user:anne` as a `writer` for `document:2021-budget`, call write API with the following  ```json {   \"writes\": {     \"tuple_keys\": [       {         \"user\": \"user:anne\",         \"relation\": \"writer\",         \"object\": \"document:2021-budget\"       }     ],     \"on_duplicate\": \"ignore\"   },   \"authorization_model_id\": \"01G50QVV17PECNVAHX1GG4Y5NC\" } ``` ### Removing relationships To remove `user:bob` as a `reader` for `document:2021-budget`, call write API with the following  ```json {   \"deletes\": {     \"tuple_keys\": [       {         \"user\": \"user:bob\",         \"relation\": \"reader\",         \"object\": \"document:2021-budget\"       }     ],     \"on_missing\": \"ignore\"   } } ``` 
 
 ### Example
 

docs/WriteRequestDeletes.md

@@ -5,6 +5,7 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **tuple_keys** | [**list[TupleKeyWithoutCondition]**](TupleKeyWithoutCondition.md) |  | 
+**on_missing** | **str** | On 'error', the API returns an error when deleting a tuple that does not exist. On 'ignore', deletes of non-existent tuples are treated as no-ops. | [optional] [default to 'error']
 
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
 

docs/WriteRequestWrites.md

@@ -5,6 +5,7 @@
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
 **tuple_keys** | [**list[TupleKey]**](TupleKey.md) |  | 
+**on_duplicate** | **str** | On 'error' ( or unspecified ), the API returns an error if an identical tuple already exists. On 'ignore', identical writes are treated as no-ops (matching on user, relation, object, and RelationshipCondition). | [optional] [default to 'error']
 
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
 

openfga_sdk/api/open_fga_api.py

@@ -2667,7 +2667,7 @@ async def streamed_list_objects_with_http_info(self, body, **kwargs):
     async def write(self, body, **kwargs):
         """Add or delete tuples from the store
 
-        The Write API will transactionally update the tuples for a certain store. Tuples and type definitions allow OpenFGA to determine whether a relationship exists between an object and an user. In the body, `writes` adds new tuples and `deletes` removes existing tuples. When deleting a tuple, any `condition` specified with it is ignored. The API is not idempotent: if, later on, you try to add the same tuple key (even if the `condition` is different), or if you try to delete a non-existing tuple, it will throw an error. The API will not allow you to write tuples such as `document:2021-budget#viewer@document:2021-budget#viewer`, because they are implicit. An `authorization_model_id` may be specified in the body. If it is, it will be used to assert that each written tuple (not deleted) is valid for the model specified. If it is not specified, the latest authorization model ID will be used. ## Example ### Adding relationships To add `user:anne` as a `writer` for `document:2021-budget`, call write API with the following  ```json {   \"writes\": {     \"tuple_keys\": [       {         \"user\": \"user:anne\",         \"relation\": \"writer\",         \"object\": \"document:2021-budget\"       }     ]   },   \"authorization_model_id\": \"01G50QVV17PECNVAHX1GG4Y5NC\" } ``` ### Removing relationships To remove `user:bob` as a `reader` for `document:2021-budget`, call write API with the following  ```json {   \"deletes\": {     \"tuple_keys\": [       {         \"user\": \"user:bob\",         \"relation\": \"reader\",         \"object\": \"document:2021-budget\"       }     ]   } } ```
+        The Write API will transactionally update the tuples for a certain store. Tuples and type definitions allow OpenFGA to determine whether a relationship exists between an object and an user. In the body, `writes` adds new tuples and `deletes` removes existing tuples. When deleting a tuple, any `condition` specified with it is ignored. The API is not idempotent by default: if, later on, you try to add the same tuple key (even if the `condition` is different), or if you try to delete a non-existing tuple, it will throw an error. To allow writes when an identical tuple already exists in the database, set `\"on_duplicate\": \"ignore\"` on the `writes` object. To allow deletes when a tuple was already removed from the database, set `\"on_missing\": \"ignore\"` on the `deletes` object. If a Write request contains both idempotent (ignore) and non-idempotent (error) operations, the most restrictive action (error) will take precedence. If a condition fails for a sub-request with an error flag, the entire transaction will be rolled back. This gives developers explicit control over the atomicity of the requests. The API will not allow you to write tuples such as `document:2021-budget#viewer@document:2021-budget#viewer`, because they are implicit. An `authorization_model_id` may be specified in the body. If it is, it will be used to assert that each written tuple (not deleted) is valid for the model specified. If it is not specified, the latest authorization model ID will be used. ## Example ### Adding relationships To add `user:anne` as a `writer` for `document:2021-budget`, call write API with the following  ```json {   \"writes\": {     \"tuple_keys\": [       {         \"user\": \"user:anne\",         \"relation\": \"writer\",         \"object\": \"document:2021-budget\"       }     ],     \"on_duplicate\": \"ignore\"   },   \"authorization_model_id\": \"01G50QVV17PECNVAHX1GG4Y5NC\" } ``` ### Removing relationships To remove `user:bob` as a `reader` for `document:2021-budget`, call write API with the following  ```json {   \"deletes\": {     \"tuple_keys\": [       {         \"user\": \"user:bob\",         \"relation\": \"reader\",         \"object\": \"document:2021-budget\"       }     ],     \"on_missing\": \"ignore\"   } } ```
 
         >>> thread = await api.write(body)
 
@@ -2694,7 +2694,7 @@ async def write(self, body, **kwargs):
     async def write_with_http_info(self, body, **kwargs):
         """Add or delete tuples from the store
 
-        The Write API will transactionally update the tuples for a certain store. Tuples and type definitions allow OpenFGA to determine whether a relationship exists between an object and an user. In the body, `writes` adds new tuples and `deletes` removes existing tuples. When deleting a tuple, any `condition` specified with it is ignored. The API is not idempotent: if, later on, you try to add the same tuple key (even if the `condition` is different), or if you try to delete a non-existing tuple, it will throw an error. The API will not allow you to write tuples such as `document:2021-budget#viewer@document:2021-budget#viewer`, because they are implicit. An `authorization_model_id` may be specified in the body. If it is, it will be used to assert that each written tuple (not deleted) is valid for the model specified. If it is not specified, the latest authorization model ID will be used. ## Example ### Adding relationships To add `user:anne` as a `writer` for `document:2021-budget`, call write API with the following  ```json {   \"writes\": {     \"tuple_keys\": [       {         \"user\": \"user:anne\",         \"relation\": \"writer\",         \"object\": \"document:2021-budget\"       }     ]   },   \"authorization_model_id\": \"01G50QVV17PECNVAHX1GG4Y5NC\" } ``` ### Removing relationships To remove `user:bob` as a `reader` for `document:2021-budget`, call write API with the following  ```json {   \"deletes\": {     \"tuple_keys\": [       {         \"user\": \"user:bob\",         \"relation\": \"reader\",         \"object\": \"document:2021-budget\"       }     ]   } } ```
+        The Write API will transactionally update the tuples for a certain store. Tuples and type definitions allow OpenFGA to determine whether a relationship exists between an object and an user. In the body, `writes` adds new tuples and `deletes` removes existing tuples. When deleting a tuple, any `condition` specified with it is ignored. The API is not idempotent by default: if, later on, you try to add the same tuple key (even if the `condition` is different), or if you try to delete a non-existing tuple, it will throw an error. To allow writes when an identical tuple already exists in the database, set `\"on_duplicate\": \"ignore\"` on the `writes` object. To allow deletes when a tuple was already removed from the database, set `\"on_missing\": \"ignore\"` on the `deletes` object. If a Write request contains both idempotent (ignore) and non-idempotent (error) operations, the most restrictive action (error) will take precedence. If a condition fails for a sub-request with an error flag, the entire transaction will be rolled back. This gives developers explicit control over the atomicity of the requests. The API will not allow you to write tuples such as `document:2021-budget#viewer@document:2021-budget#viewer`, because they are implicit. An `authorization_model_id` may be specified in the body. If it is, it will be used to assert that each written tuple (not deleted) is valid for the model specified. If it is not specified, the latest authorization model ID will be used. ## Example ### Adding relationships To add `user:anne` as a `writer` for `document:2021-budget`, call write API with the following  ```json {   \"writes\": {     \"tuple_keys\": [       {         \"user\": \"user:anne\",         \"relation\": \"writer\",         \"object\": \"document:2021-budget\"       }     ],     \"on_duplicate\": \"ignore\"   },   \"authorization_model_id\": \"01G50QVV17PECNVAHX1GG4Y5NC\" } ``` ### Removing relationships To remove `user:bob` as a `reader` for `document:2021-budget`, call write API with the following  ```json {   \"deletes\": {     \"tuple_keys\": [       {         \"user\": \"user:bob\",         \"relation\": \"reader\",         \"object\": \"document:2021-budget\"       }     ],     \"on_missing\": \"ignore\"   } } ```
 
         >>> thread = api.write_with_http_info(body)
 

openfga_sdk/models/write_request_deletes.py

@@ -31,20 +31,31 @@ class WriteRequestDeletes:
       attribute_map (dict): The key is attribute name
                             and the value is json key in definition.
     """
-    openapi_types: dict[str, str] = {"tuple_keys": "list[TupleKeyWithoutCondition]"}
-
-    attribute_map: dict[str, str] = {"tuple_keys": "tuple_keys"}
-
-    def __init__(self, tuple_keys=None, local_vars_configuration=None):
+    openapi_types: dict[str, str] = {
+        "tuple_keys": "list[TupleKeyWithoutCondition]",
+        "on_missing": "str",
+    }
+
+    attribute_map: dict[str, str] = {
+        "tuple_keys": "tuple_keys",
+        "on_missing": "on_missing",
+    }
+
+    def __init__(
+        self, tuple_keys=None, on_missing="error", local_vars_configuration=None
+    ):
         """WriteRequestDeletes - a model defined in OpenAPI"""
         if local_vars_configuration is None:
             local_vars_configuration = Configuration.get_default_copy()
         self.local_vars_configuration = local_vars_configuration
 
         self._tuple_keys = None
+        self._on_missing = None
         self.discriminator = None
 
         self.tuple_keys = tuple_keys
+        if on_missing is not None:
+            self.on_missing = on_missing
 
     @property
     def tuple_keys(self):
@@ -69,6 +80,39 @@ def tuple_keys(self, tuple_keys):
 
         self._tuple_keys = tuple_keys
 
+    @property
+    def on_missing(self):
+        """Gets the on_missing of this WriteRequestDeletes.
+
+        On 'error', the API returns an error when deleting a tuple that does not exist. On 'ignore', deletes of non-existent tuples are treated as no-ops.
+
+        :return: The on_missing of this WriteRequestDeletes.
+        :rtype: str
+        """
+        return self._on_missing
+
+    @on_missing.setter
+    def on_missing(self, on_missing):
+        """Sets the on_missing of this WriteRequestDeletes.
+
+        On 'error', the API returns an error when deleting a tuple that does not exist. On 'ignore', deletes of non-existent tuples are treated as no-ops.
+
+        :param on_missing: The on_missing of this WriteRequestDeletes.
+        :type on_missing: str
+        """
+        allowed_values = ["error", "ignore"]
+        if (
+            self.local_vars_configuration.client_side_validation
+            and on_missing not in allowed_values
+        ):
+            raise ValueError(
+                "Invalid value for `on_missing` ({0}), must be one of {1}".format(
+                    on_missing, allowed_values
+                )
+            )
+
+        self._on_missing = on_missing
+
     def to_dict(self, serialize=False):
         """Returns the model properties as a dict"""
         result = {}

openfga_sdk/models/write_request_writes.py

@@ -31,20 +31,31 @@ class WriteRequestWrites:
       attribute_map (dict): The key is attribute name
                             and the value is json key in definition.
     """
-    openapi_types: dict[str, str] = {"tuple_keys": "list[TupleKey]"}
-
-    attribute_map: dict[str, str] = {"tuple_keys": "tuple_keys"}
-
-    def __init__(self, tuple_keys=None, local_vars_configuration=None):
+    openapi_types: dict[str, str] = {
+        "tuple_keys": "list[TupleKey]",
+        "on_duplicate": "str",
+    }
+
+    attribute_map: dict[str, str] = {
+        "tuple_keys": "tuple_keys",
+        "on_duplicate": "on_duplicate",
+    }
+
+    def __init__(
+        self, tuple_keys=None, on_duplicate="error", local_vars_configuration=None
+    ):
         """WriteRequestWrites - a model defined in OpenAPI"""
         if local_vars_configuration is None:
             local_vars_configuration = Configuration.get_default_copy()
         self.local_vars_configuration = local_vars_configuration
 
         self._tuple_keys = None
+        self._on_duplicate = None
         self.discriminator = None
 
         self.tuple_keys = tuple_keys
+        if on_duplicate is not None:
+            self.on_duplicate = on_duplicate
 
     @property
     def tuple_keys(self):
@@ -69,6 +80,39 @@ def tuple_keys(self, tuple_keys):
 
         self._tuple_keys = tuple_keys
 
+    @property
+    def on_duplicate(self):
+        """Gets the on_duplicate of this WriteRequestWrites.
+
+        On 'error' ( or unspecified ), the API returns an error if an identical tuple already exists. On 'ignore', identical writes are treated as no-ops (matching on user, relation, object, and RelationshipCondition).
+
+        :return: The on_duplicate of this WriteRequestWrites.
+        :rtype: str
+        """
+        return self._on_duplicate
+
+    @on_duplicate.setter
+    def on_duplicate(self, on_duplicate):
+        """Sets the on_duplicate of this WriteRequestWrites.
+
+        On 'error' ( or unspecified ), the API returns an error if an identical tuple already exists. On 'ignore', identical writes are treated as no-ops (matching on user, relation, object, and RelationshipCondition).
+
+        :param on_duplicate: The on_duplicate of this WriteRequestWrites.
+        :type on_duplicate: str
+        """
+        allowed_values = ["error", "ignore"]
+        if (
+            self.local_vars_configuration.client_side_validation
+            and on_duplicate not in allowed_values
+        ):
+            raise ValueError(
+                "Invalid value for `on_duplicate` ({0}), must be one of {1}".format(
+                    on_duplicate, allowed_values
+                )
+            )
+
+        self._on_duplicate = on_duplicate
+
     def to_dict(self, serialize=False):
         """Returns the model properties as a dict"""
         result = {}

openfga_sdk/sync/oauth2.py

@@ -70,7 +70,7 @@ def _obtain_token(self, client):
         """
         configuration = self._credentials.configuration
 
-        token_url = f"https://{configuration.api_issuer}/oauth/token"
+        token_url = self._credentials._parse_issuer(configuration.api_issuer)
 
         post_params = {
             "client_id": configuration.client_id,