agilicus 1.295.1__py3-none-any.whl → 1.295.2__py3-none-any.whl

agilicus/.openapi-generator/FILES

@@ -396,6 +396,8 @@ agilicus_api/docs/HttpRequestExtractorSource.md
 agilicus_api/docs/HttpRule.md
 agilicus_api/docs/HttpRuleCondition.md
 agilicus_api/docs/HttpRuleConditionType.md
+agilicus_api/docs/HypotheticalLicenseDetails.md
+agilicus_api/docs/HypotheticalLicenseDetailsQuery.md
 agilicus_api/docs/Icon.md
 agilicus_api/docs/IconDimensions.md
 agilicus_api/docs/IconPurpose.md
@@ -1295,6 +1297,8 @@ agilicus_api/model/http_rule_condition.py
 agilicus_api/model/http_rule_condition_type.py
 agilicus_api/model/http_security_settings.py
 agilicus_api/model/http_summary_stats.py
+agilicus_api/model/hypothetical_license_details.py
+agilicus_api/model/hypothetical_license_details_query.py
 agilicus_api/model/icon.py
 agilicus_api/model/icon_dimensions.py
 agilicus_api/model/icon_purpose.py
@@ -2191,6 +2195,8 @@ agilicus_api/test/test_http_rule_condition.py
 agilicus_api/test/test_http_rule_condition_type.py
 agilicus_api/test/test_http_security_settings.py
 agilicus_api/test/test_http_summary_stats.py
+agilicus_api/test/test_hypothetical_license_details.py
+agilicus_api/test/test_hypothetical_license_details_query.py
 agilicus_api/test/test_icon.py
 agilicus_api/test/test_icon_dimensions.py
 agilicus_api/test/test_icon_purpose.py

agilicus/agilicus_api/__init__.py

@@ -374,6 +374,8 @@ from agilicus_api.model.http_request_extractor_source import HttpRequestExtracto
 from agilicus_api.model.http_rule import HttpRule
 from agilicus_api.model.http_rule_condition import HttpRuleCondition
 from agilicus_api.model.http_rule_condition_type import HttpRuleConditionType
+from agilicus_api.model.hypothetical_license_details import HypotheticalLicenseDetails
+from agilicus_api.model.hypothetical_license_details_query import HypotheticalLicenseDetailsQuery
 from agilicus_api.model.icon import Icon
 from agilicus_api.model.icon_dimensions import IconDimensions
 from agilicus_api.model.icon_purpose import IconPurpose

agilicus/agilicus_api/api/licensing_api.py

@@ -23,6 +23,8 @@ from agilicus_api.model_utils import (  # noqa: F401
     validate_and_convert_types
 )
 from agilicus_api.model.error_message import ErrorMessage
+from agilicus_api.model.hypothetical_license_details import HypotheticalLicenseDetails
+from agilicus_api.model.hypothetical_license_details_query import HypotheticalLicenseDetailsQuery
 from agilicus_api.model.license import License
 from agilicus_api.model.list_license_details_response import ListLicenseDetailsResponse
 from agilicus_api.model.list_licenses_response import ListLicensesResponse
@@ -42,6 +44,127 @@ class LicensingApi(object):
             api_client = ApiClient()
         self.api_client = api_client
 
+        def __create_hypothetical_license_details_query(
+            self,
+            hypothetical_license_details_query,
+            **kwargs
+        ):
+            """Query a hypothetical set of license details  # noqa: E501
+
+            Get all per-org license details matching the query. This will return the actual constraints available to an organisation, taking into account their product, the hypothetical version of the product table, and any overrides applied to their organisation. Multiple organisations' constraints may be returned at a time.   # noqa: E501
+            This method makes a synchronous HTTP request by default. To make an
+            asynchronous HTTP request, please pass async_req=True
+
+            >>> thread = api.create_hypothetical_license_details_query(hypothetical_license_details_query, async_req=True)
+            >>> result = thread.get()
+
+            Args:
+                hypothetical_license_details_query (HypotheticalLicenseDetailsQuery):
+
+            Keyword Args:
+                _return_http_data_only (bool): response data without head status
+                    code and headers. Default is True.
+                _preload_content (bool): if False, the urllib3.HTTPResponse object
+                    will be returned without reading/decoding response data.
+                    Default is True.
+                _request_timeout (float/tuple): timeout setting for this request. If one
+                    number provided, it will be total request timeout. It can also
+                    be a pair (tuple) of (connection, read) timeouts.
+                    Default is None.
+                _check_input_type (bool): specifies if type checking
+                    should be done one the data sent to the server.
+                    Default is True.
+                _check_return_type (bool): specifies if type checking
+                    should be done one the data received from the server.
+                    Default is True.
+                _host_index (int/None): specifies the index of the server
+                    that we want to use.
+                    Default is read from the configuration.
+                async_req (bool): execute request asynchronously
+
+            Returns:
+                HypotheticalLicenseDetails
+                    If the method is called asynchronously, returns the request
+                    thread.
+            """
+            kwargs['async_req'] = kwargs.get(
+                'async_req', False
+            )
+            kwargs['_return_http_data_only'] = kwargs.get(
+                '_return_http_data_only', True
+            )
+            kwargs['_preload_content'] = kwargs.get(
+                '_preload_content', True
+            )
+            kwargs['_request_timeout'] = kwargs.get(
+                '_request_timeout', None
+            )
+            kwargs['_check_input_type'] = kwargs.get(
+                '_check_input_type', True
+            )
+            kwargs['_check_return_type'] = kwargs.get(
+                '_check_return_type', True
+            )
+            kwargs['_host_index'] = kwargs.get('_host_index')
+            kwargs['hypothetical_license_details_query'] = \
+                hypothetical_license_details_query
+            return self.call_with_http_info(**kwargs)
+
+        if self.create_hypothetical_license_details_query is None:
+            self.create_hypothetical_license_details_query = _Endpoint(
+                settings={
+                    'response_type': (HypotheticalLicenseDetails,),
+                    'auth': [
+                        'token-valid'
+                    ],
+                    'endpoint_path': '/v1/license_details/hypothetical',
+                    'operation_id': 'create_hypothetical_license_details_query',
+                    'http_method': 'POST',
+                    'servers': None,
+                },
+                params_map={
+                    'all': [
+                        'hypothetical_license_details_query',
+                    ],
+                    'required': [
+                        'hypothetical_license_details_query',
+                    ],
+                    'nullable': [
+                    ],
+                    'enum': [
+                    ],
+                    'validation': [
+                    ]
+                },
+                root_map={
+                    'validations': {
+                    },
+                    'allowed_values': {
+                    },
+                    'openapi_types': {
+                        'hypothetical_license_details_query':
+                            (HypotheticalLicenseDetailsQuery,),
+                    },
+                    'attribute_map': {
+                    },
+                    'location_map': {
+                        'hypothetical_license_details_query': 'body',
+                    },
+                    'collection_format_map': {
+                    }
+                },
+                headers_map={
+                    'accept': [
+                        'application/json'
+                    ],
+                    'content_type': [
+                        'application/json'
+                    ]
+                },
+                api_client=api_client,
+                callable=__create_hypothetical_license_details_query
+            )
+
         def __create_license(
             self,
             license,
@@ -1427,6 +1550,7 @@ class LicensingApi(object):
                 callable=__replace_product_table_version
             )
 
+    create_hypothetical_license_details_query = None 
     create_license = None 
     create_product_table_version = None 
     delete_license = None 

agilicus/agilicus_api/api/licensing_api_mock.py

@@ -3,6 +3,7 @@ from unittest.mock import MagicMock
 class LicensingApiMock:
 
     def __init__(self):
+        self.mock_create_hypothetical_license_details_query = MagicMock()
         self.mock_create_license = MagicMock()
         self.mock_create_product_table_version = MagicMock()
         self.mock_delete_license = MagicMock()
@@ -15,6 +16,12 @@ class LicensingApiMock:
         self.mock_replace_license = MagicMock()
         self.mock_replace_product_table_version = MagicMock()
 
+    def create_hypothetical_license_details_query(self, *args, **kwargs):
+        """
+        This method mocks the original api LicensingApi.create_hypothetical_license_details_query with MagicMock.
+        """
+        return self.mock_create_hypothetical_license_details_query(self, *args, **kwargs)
+
     def create_license(self, *args, **kwargs):
         """
         This method mocks the original api LicensingApi.create_license with MagicMock.

agilicus/agilicus_api/api_client.py

@@ -77,7 +77,7 @@ class ApiClient(object):
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/1.295.1/python'
+        self.user_agent = 'OpenAPI-Generator/1.295.2/python'
 
     def __enter__(self):
         return self

agilicus/agilicus_api/configuration.py

@@ -387,7 +387,7 @@ class Configuration(object):
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 2025.07.18\n"\
-               "SDK Package Version: 1.295.1".\
+               "SDK Package Version: 1.295.2".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self):

agilicus/agilicus_api/docs/HypotheticalLicenseDetails.md

@@ -0,0 +1,13 @@
+# HypotheticalLicenseDetails
+
+The license details matching the HypotheticalLicenseDetailsQuery
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**license_details** | [**[LicenseDetails]**](LicenseDetails.md) | List of per-org license details | 
+**any string name** | **bool, date, datetime, dict, float, int, list, str, none_type** | any string name can be used but the value must be the correct type | [optional]
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+

agilicus/agilicus_api/docs/HypotheticalLicenseDetailsQuery.md

@@ -0,0 +1,15 @@
+# HypotheticalLicenseDetailsQuery
+
+Defines a query which allows for returning the LicenseDetails under a hypothetical product table.  The results can be controlled in a few ways:  - constrain_to_version: can be used to test what would happen if all orgs using the provided    version were swapped to the provided hypothetical version.  This enables a few use-cases:    1. When modifying an existing table, only show the results for customers who would actually be affected by applying it.    2. See what would happen when migrating customers with other versions of the table to this version.    3. As a special case of number 2, see what would happen when making an entirely new version then migrating a set of customers to it. 
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**product_table_version** | [**ProductTableVersion**](ProductTableVersion.md) |  | 
+**license_ids** | **[str]** | List of licenses for which to get details | 
+**constrain_to_version** | [**ProductTableVersionString**](ProductTableVersionString.md) |  | [optional] 
+**any string name** | **bool, date, datetime, dict, float, int, list, str, none_type** | any string name can be used but the value must be the correct type | [optional]
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+

agilicus/agilicus_api/docs/LicensingApi.md

@@ -4,6 +4,7 @@ All URIs are relative to *https://api.agilicus.com*
 
 Method | HTTP request | Description
 ------------- | ------------- | -------------
+[**create_hypothetical_license_details_query**](LicensingApi.md#create_hypothetical_license_details_query) | **POST** /v1/license_details/hypothetical | Query a hypothetical set of license details
 [**create_license**](LicensingApi.md#create_license) | **POST** /v1/licenses | Create a license
 [**create_product_table_version**](LicensingApi.md#create_product_table_version) | **POST** /v1/product_table_versions | Create a product table version
 [**delete_license**](LicensingApi.md#delete_license) | **DELETE** /v1/licenses/{license_id} | Delete a license
@@ -17,6 +18,136 @@ Method | HTTP request | Description
 [**replace_product_table_version**](LicensingApi.md#replace_product_table_version) | **PUT** /v1/product_table_versions/{product_table_version_id} | Create or update a product table version
 
 
+# **create_hypothetical_license_details_query**
+> HypotheticalLicenseDetails create_hypothetical_license_details_query(hypothetical_license_details_query)
+
+Query a hypothetical set of license details
+
+Get all per-org license details matching the query. This will return the actual constraints available to an organisation, taking into account their product, the hypothetical version of the product table, and any overrides applied to their organisation. Multiple organisations' constraints may be returned at a time. 
+
+### Example
+
+* Bearer (JWT) Authentication (token-valid):
+```python
+import time
+import agilicus_api
+from agilicus_api.api import licensing_api
+from agilicus_api.model.hypothetical_license_details import HypotheticalLicenseDetails
+from agilicus_api.model.hypothetical_license_details_query import HypotheticalLicenseDetailsQuery
+from pprint import pprint
+# Defining the host is optional and defaults to https://api.agilicus.com
+# See configuration.py for a list of all supported configuration parameters.
+configuration = agilicus_api.Configuration(
+    host = "https://api.agilicus.com"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): token-valid
+configuration = agilicus_api.Configuration(
+    access_token = 'YOUR_BEARER_TOKEN'
+)
+
+# Enter a context with an instance of the API client
+with agilicus_api.ApiClient(configuration) as api_client:
+    # Create an instance of the API class
+    api_instance = licensing_api.LicensingApi(api_client)
+    hypothetical_license_details_query = HypotheticalLicenseDetailsQuery(
+        product_table_version=ProductTableVersion(
+            metadata=MetadataWithId(),
+            spec=ProductTableVersionSpec(
+                version=ProductTableVersionString("2025-06-13.0"),
+                product_table=ProductTable(
+                    products=[
+                        LicensedProduct(
+                            name=LicensedProductName("Standard"),
+                            included_features=[
+                                LicensedFeatureName("Desktops"),
+                            ],
+                            license_constraints=[
+                                LicenseConstraint(
+                                    name=LicenseConstraintName("desktops_below_max"),
+                                    expression=LicenseConstraintExpression("subscription.usage.num_desktops < 10"),
+                                    priority=0,
+                                    comment="Uses the max_desktops from the product to enforce a limit on desktops",
+                                ),
+                            ],
+                            constraint_variables=LicenseConstraintVariables(),
+                        ),
+                    ],
+                    features=[
+                        LicensedFeature(
+                            name=LicensedFeatureName("Desktops"),
+                            license_constraints=[
+                                LicenseConstraint(
+                                    name=LicenseConstraintName("desktops_below_max"),
+                                    expression=LicenseConstraintExpression("subscription.usage.num_desktops < 10"),
+                                    priority=0,
+                                    comment="Uses the max_desktops from the product to enforce a limit on desktops",
+                                ),
+                            ],
+                            constraint_variables=LicenseConstraintVariables(),
+                        ),
+                    ],
+                    constraint_variables=LicenseConstraintVariables(),
+                    global_constraints=[
+                        LicenseConstraint(
+                            name=LicenseConstraintName("desktops_below_max"),
+                            expression=LicenseConstraintExpression("subscription.usage.num_desktops < 10"),
+                            priority=0,
+                            comment="Uses the max_desktops from the product to enforce a limit on desktops",
+                        ),
+                    ],
+                ),
+                published=True,
+            ),
+        ),
+        license_ids=[
+            "123",
+        ],
+        constrain_to_version=ProductTableVersionString("2025-06-13.0"),
+    ) # HypotheticalLicenseDetailsQuery | 
+
+    # example passing only required values which don't have defaults set
+    try:
+        # Query a hypothetical set of license details
+        api_response = api_instance.create_hypothetical_license_details_query(hypothetical_license_details_query)
+        pprint(api_response)
+    except agilicus_api.ApiException as e:
+        print("Exception when calling LicensingApi->create_hypothetical_license_details_query: %s\n" % e)
+```
+
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **hypothetical_license_details_query** | [**HypotheticalLicenseDetailsQuery**](HypotheticalLicenseDetailsQuery.md)|  |
+
+### Return type
+
+[**HypotheticalLicenseDetails**](HypotheticalLicenseDetails.md)
+
+### Authorization
+
+[token-valid](../README.md#token-valid)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+
+### HTTP response details
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | Matching license details returned |  -  |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
 # **create_license**
 > License create_license(license)