pulumi-tls 4.12.0a1698440106__py3-none-any.whl → 4.12.0a1699566381__py3-none-any.whl

pulumi_tls/outputs.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 
 __all__ = [
@@ -63,61 +63,24 @@ class CertRequestSubject(dict):
         :param str serial_number: Distinguished name: `SERIALNUMBER`
         :param Sequence[str] street_addresses: Distinguished name: `STREET`
         """
-        CertRequestSubject._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            common_name=common_name,
-            country=country,
-            locality=locality,
-            organization=organization,
-            organizational_unit=organizational_unit,
-            postal_code=postal_code,
-            province=province,
-            serial_number=serial_number,
-            street_addresses=street_addresses,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             common_name: Optional[str] = None,
-             country: Optional[str] = None,
-             locality: Optional[str] = None,
-             organization: Optional[str] = None,
-             organizational_unit: Optional[str] = None,
-             postal_code: Optional[str] = None,
-             province: Optional[str] = None,
-             serial_number: Optional[str] = None,
-             street_addresses: Optional[Sequence[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if common_name is None and 'commonName' in kwargs:
-            common_name = kwargs['commonName']
-        if organizational_unit is None and 'organizationalUnit' in kwargs:
-            organizational_unit = kwargs['organizationalUnit']
-        if postal_code is None and 'postalCode' in kwargs:
-            postal_code = kwargs['postalCode']
-        if serial_number is None and 'serialNumber' in kwargs:
-            serial_number = kwargs['serialNumber']
-        if street_addresses is None and 'streetAddresses' in kwargs:
-            street_addresses = kwargs['streetAddresses']
-
         if common_name is not None:
-            _setter("common_name", common_name)
+            pulumi.set(__self__, "common_name", common_name)
         if country is not None:
-            _setter("country", country)
+            pulumi.set(__self__, "country", country)
         if locality is not None:
-            _setter("locality", locality)
+            pulumi.set(__self__, "locality", locality)
         if organization is not None:
-            _setter("organization", organization)
+            pulumi.set(__self__, "organization", organization)
         if organizational_unit is not None:
-            _setter("organizational_unit", organizational_unit)
+            pulumi.set(__self__, "organizational_unit", organizational_unit)
         if postal_code is not None:
-            _setter("postal_code", postal_code)
+            pulumi.set(__self__, "postal_code", postal_code)
         if province is not None:
-            _setter("province", province)
+            pulumi.set(__self__, "province", province)
         if serial_number is not None:
-            _setter("serial_number", serial_number)
+            pulumi.set(__self__, "serial_number", serial_number)
         if street_addresses is not None:
-            _setter("street_addresses", street_addresses)
+            pulumi.set(__self__, "street_addresses", street_addresses)
 
     @property
     @pulumi.getter(name="commonName")
@@ -240,61 +203,24 @@ class SelfSignedCertSubject(dict):
         :param str serial_number: Distinguished name: `SERIALNUMBER`
         :param Sequence[str] street_addresses: Distinguished name: `STREET`
         """
-        SelfSignedCertSubject._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            common_name=common_name,
-            country=country,
-            locality=locality,
-            organization=organization,
-            organizational_unit=organizational_unit,
-            postal_code=postal_code,
-            province=province,
-            serial_number=serial_number,
-            street_addresses=street_addresses,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             common_name: Optional[str] = None,
-             country: Optional[str] = None,
-             locality: Optional[str] = None,
-             organization: Optional[str] = None,
-             organizational_unit: Optional[str] = None,
-             postal_code: Optional[str] = None,
-             province: Optional[str] = None,
-             serial_number: Optional[str] = None,
-             street_addresses: Optional[Sequence[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if common_name is None and 'commonName' in kwargs:
-            common_name = kwargs['commonName']
-        if organizational_unit is None and 'organizationalUnit' in kwargs:
-            organizational_unit = kwargs['organizationalUnit']
-        if postal_code is None and 'postalCode' in kwargs:
-            postal_code = kwargs['postalCode']
-        if serial_number is None and 'serialNumber' in kwargs:
-            serial_number = kwargs['serialNumber']
-        if street_addresses is None and 'streetAddresses' in kwargs:
-            street_addresses = kwargs['streetAddresses']
-
         if common_name is not None:
-            _setter("common_name", common_name)
+            pulumi.set(__self__, "common_name", common_name)
         if country is not None:
-            _setter("country", country)
+            pulumi.set(__self__, "country", country)
         if locality is not None:
-            _setter("locality", locality)
+            pulumi.set(__self__, "locality", locality)
         if organization is not None:
-            _setter("organization", organization)
+            pulumi.set(__self__, "organization", organization)
         if organizational_unit is not None:
-            _setter("organizational_unit", organizational_unit)
+            pulumi.set(__self__, "organizational_unit", organizational_unit)
         if postal_code is not None:
-            _setter("postal_code", postal_code)
+            pulumi.set(__self__, "postal_code", postal_code)
         if province is not None:
-            _setter("province", province)
+            pulumi.set(__self__, "province", province)
         if serial_number is not None:
-            _setter("serial_number", serial_number)
+            pulumi.set(__self__, "serial_number", serial_number)
         if street_addresses is not None:
-            _setter("street_addresses", street_addresses)
+            pulumi.set(__self__, "street_addresses", street_addresses)
 
     @property
     @pulumi.getter(name="commonName")
@@ -397,86 +323,17 @@ class GetCertificateCertificateResult(dict):
         :param str subject: The entity the certificate belongs to, roughly following [RFC2253](https://tools.ietf.org/html/rfc2253).
         :param int version: The version the certificate is in.
         """
-        GetCertificateCertificateResult._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            cert_pem=cert_pem,
-            is_ca=is_ca,
-            issuer=issuer,
-            not_after=not_after,
-            not_before=not_before,
-            public_key_algorithm=public_key_algorithm,
-            serial_number=serial_number,
-            sha1_fingerprint=sha1_fingerprint,
-            signature_algorithm=signature_algorithm,
-            subject=subject,
-            version=version,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             cert_pem: Optional[str] = None,
-             is_ca: Optional[bool] = None,
-             issuer: Optional[str] = None,
-             not_after: Optional[str] = None,
-             not_before: Optional[str] = None,
-             public_key_algorithm: Optional[str] = None,
-             serial_number: Optional[str] = None,
-             sha1_fingerprint: Optional[str] = None,
-             signature_algorithm: Optional[str] = None,
-             subject: Optional[str] = None,
-             version: Optional[int] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if cert_pem is None and 'certPem' in kwargs:
-            cert_pem = kwargs['certPem']
-        if cert_pem is None:
-            raise TypeError("Missing 'cert_pem' argument")
-        if is_ca is None and 'isCa' in kwargs:
-            is_ca = kwargs['isCa']
-        if is_ca is None:
-            raise TypeError("Missing 'is_ca' argument")
-        if issuer is None:
-            raise TypeError("Missing 'issuer' argument")
-        if not_after is None and 'notAfter' in kwargs:
-            not_after = kwargs['notAfter']
-        if not_after is None:
-            raise TypeError("Missing 'not_after' argument")
-        if not_before is None and 'notBefore' in kwargs:
-            not_before = kwargs['notBefore']
-        if not_before is None:
-            raise TypeError("Missing 'not_before' argument")
-        if public_key_algorithm is None and 'publicKeyAlgorithm' in kwargs:
-            public_key_algorithm = kwargs['publicKeyAlgorithm']
-        if public_key_algorithm is None:
-            raise TypeError("Missing 'public_key_algorithm' argument")
-        if serial_number is None and 'serialNumber' in kwargs:
-            serial_number = kwargs['serialNumber']
-        if serial_number is None:
-            raise TypeError("Missing 'serial_number' argument")
-        if sha1_fingerprint is None and 'sha1Fingerprint' in kwargs:
-            sha1_fingerprint = kwargs['sha1Fingerprint']
-        if sha1_fingerprint is None:
-            raise TypeError("Missing 'sha1_fingerprint' argument")
-        if signature_algorithm is None and 'signatureAlgorithm' in kwargs:
-            signature_algorithm = kwargs['signatureAlgorithm']
-        if signature_algorithm is None:
-            raise TypeError("Missing 'signature_algorithm' argument")
-        if subject is None:
-            raise TypeError("Missing 'subject' argument")
-        if version is None:
-            raise TypeError("Missing 'version' argument")
-
-        _setter("cert_pem", cert_pem)
-        _setter("is_ca", is_ca)
-        _setter("issuer", issuer)
-        _setter("not_after", not_after)
-        _setter("not_before", not_before)
-        _setter("public_key_algorithm", public_key_algorithm)
-        _setter("serial_number", serial_number)
-        _setter("sha1_fingerprint", sha1_fingerprint)
-        _setter("signature_algorithm", signature_algorithm)
-        _setter("subject", subject)
-        _setter("version", version)
+        pulumi.set(__self__, "cert_pem", cert_pem)
+        pulumi.set(__self__, "is_ca", is_ca)
+        pulumi.set(__self__, "issuer", issuer)
+        pulumi.set(__self__, "not_after", not_after)
+        pulumi.set(__self__, "not_before", not_before)
+        pulumi.set(__self__, "public_key_algorithm", public_key_algorithm)
+        pulumi.set(__self__, "serial_number", serial_number)
+        pulumi.set(__self__, "sha1_fingerprint", sha1_fingerprint)
+        pulumi.set(__self__, "signature_algorithm", signature_algorithm)
+        pulumi.set(__self__, "subject", subject)
+        pulumi.set(__self__, "version", version)
 
     @property
     @pulumi.getter(name="certPem")

pulumi_tls/private_key.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 
 __all__ = ['PrivateKeyArgs', 'PrivateKey']
@@ -23,32 +23,11 @@ class PrivateKeyArgs:
         :param pulumi.Input[str] ecdsa_curve: When `algorithm` is `ECDSA`, the name of the elliptic curve to use. Currently-supported values are `P224`, `P256`, `P384` or `P521` (default: `P224`).
         :param pulumi.Input[int] rsa_bits: When `algorithm` is `RSA`, the size of the generated RSA key, in bits (default: `2048`).
         """
-        PrivateKeyArgs._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            algorithm=algorithm,
-            ecdsa_curve=ecdsa_curve,
-            rsa_bits=rsa_bits,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             algorithm: Optional[pulumi.Input[str]] = None,
-             ecdsa_curve: Optional[pulumi.Input[str]] = None,
-             rsa_bits: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if algorithm is None:
-            raise TypeError("Missing 'algorithm' argument")
-        if ecdsa_curve is None and 'ecdsaCurve' in kwargs:
-            ecdsa_curve = kwargs['ecdsaCurve']
-        if rsa_bits is None and 'rsaBits' in kwargs:
-            rsa_bits = kwargs['rsaBits']
-
-        _setter("algorithm", algorithm)
+        pulumi.set(__self__, "algorithm", algorithm)
         if ecdsa_curve is not None:
-            _setter("ecdsa_curve", ecdsa_curve)
+            pulumi.set(__self__, "ecdsa_curve", ecdsa_curve)
         if rsa_bits is not None:
-            _setter("rsa_bits", rsa_bits)
+            pulumi.set(__self__, "rsa_bits", rsa_bits)
 
     @property
     @pulumi.getter
@@ -111,67 +90,24 @@ class _PrivateKeyState:
         :param pulumi.Input[str] public_key_pem: Public key data in PEM (RFC 1421).
         :param pulumi.Input[int] rsa_bits: When `algorithm` is `RSA`, the size of the generated RSA key, in bits (default: `2048`).
         """
-        _PrivateKeyState._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            algorithm=algorithm,
-            ecdsa_curve=ecdsa_curve,
-            private_key_openssh=private_key_openssh,
-            private_key_pem=private_key_pem,
-            public_key_fingerprint_md5=public_key_fingerprint_md5,
-            public_key_fingerprint_sha256=public_key_fingerprint_sha256,
-            public_key_openssh=public_key_openssh,
-            public_key_pem=public_key_pem,
-            rsa_bits=rsa_bits,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             algorithm: Optional[pulumi.Input[str]] = None,
-             ecdsa_curve: Optional[pulumi.Input[str]] = None,
-             private_key_openssh: Optional[pulumi.Input[str]] = None,
-             private_key_pem: Optional[pulumi.Input[str]] = None,
-             public_key_fingerprint_md5: Optional[pulumi.Input[str]] = None,
-             public_key_fingerprint_sha256: Optional[pulumi.Input[str]] = None,
-             public_key_openssh: Optional[pulumi.Input[str]] = None,
-             public_key_pem: Optional[pulumi.Input[str]] = None,
-             rsa_bits: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if ecdsa_curve is None and 'ecdsaCurve' in kwargs:
-            ecdsa_curve = kwargs['ecdsaCurve']
-        if private_key_openssh is None and 'privateKeyOpenssh' in kwargs:
-            private_key_openssh = kwargs['privateKeyOpenssh']
-        if private_key_pem is None and 'privateKeyPem' in kwargs:
-            private_key_pem = kwargs['privateKeyPem']
-        if public_key_fingerprint_md5 is None and 'publicKeyFingerprintMd5' in kwargs:
-            public_key_fingerprint_md5 = kwargs['publicKeyFingerprintMd5']
-        if public_key_fingerprint_sha256 is None and 'publicKeyFingerprintSha256' in kwargs:
-            public_key_fingerprint_sha256 = kwargs['publicKeyFingerprintSha256']
-        if public_key_openssh is None and 'publicKeyOpenssh' in kwargs:
-            public_key_openssh = kwargs['publicKeyOpenssh']
-        if public_key_pem is None and 'publicKeyPem' in kwargs:
-            public_key_pem = kwargs['publicKeyPem']
-        if rsa_bits is None and 'rsaBits' in kwargs:
-            rsa_bits = kwargs['rsaBits']
-
         if algorithm is not None:
-            _setter("algorithm", algorithm)
+            pulumi.set(__self__, "algorithm", algorithm)
         if ecdsa_curve is not None:
-            _setter("ecdsa_curve", ecdsa_curve)
+            pulumi.set(__self__, "ecdsa_curve", ecdsa_curve)
         if private_key_openssh is not None:
-            _setter("private_key_openssh", private_key_openssh)
+            pulumi.set(__self__, "private_key_openssh", private_key_openssh)
         if private_key_pem is not None:
-            _setter("private_key_pem", private_key_pem)
+            pulumi.set(__self__, "private_key_pem", private_key_pem)
         if public_key_fingerprint_md5 is not None:
-            _setter("public_key_fingerprint_md5", public_key_fingerprint_md5)
+            pulumi.set(__self__, "public_key_fingerprint_md5", public_key_fingerprint_md5)
         if public_key_fingerprint_sha256 is not None:
-            _setter("public_key_fingerprint_sha256", public_key_fingerprint_sha256)
+            pulumi.set(__self__, "public_key_fingerprint_sha256", public_key_fingerprint_sha256)
         if public_key_openssh is not None:
-            _setter("public_key_openssh", public_key_openssh)
+            pulumi.set(__self__, "public_key_openssh", public_key_openssh)
         if public_key_pem is not None:
-            _setter("public_key_pem", public_key_pem)
+            pulumi.set(__self__, "public_key_pem", public_key_pem)
         if rsa_bits is not None:
-            _setter("rsa_bits", rsa_bits)
+            pulumi.set(__self__, "rsa_bits", rsa_bits)
 
     @property
     @pulumi.getter
@@ -317,10 +253,6 @@ class PrivateKey(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
-            kwargs = kwargs or {}
-            def _setter(key, value):
-                kwargs[key] = value
-            PrivateKeyArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,

pulumi_tls/provider.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from ._inputs import *
 
@@ -20,19 +20,8 @@ class ProviderArgs:
         The set of arguments for constructing a Provider resource.
         :param pulumi.Input['ProviderProxyArgs'] proxy: Proxy used by resources and data sources that connect to external endpoints.
         """
-        ProviderArgs._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            proxy=proxy,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             proxy: Optional[pulumi.Input['ProviderProxyArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-
         if proxy is not None:
-            _setter("proxy", proxy)
+            pulumi.set(__self__, "proxy", proxy)
 
     @property
     @pulumi.getter
@@ -86,10 +75,6 @@ class Provider(pulumi.ProviderResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
-            kwargs = kwargs or {}
-            def _setter(key, value):
-                kwargs[key] = value
-            ProviderArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,
@@ -105,7 +90,6 @@ class Provider(pulumi.ProviderResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = ProviderArgs.__new__(ProviderArgs)
 
-            proxy = _utilities.configure(proxy, ProviderProxyArgs, True)
             __props__.__dict__["proxy"] = pulumi.Output.from_input(proxy).apply(pulumi.runtime.to_json) if proxy is not None else None
         super(Provider, __self__).__init__(
             'tls',