github.com/myhau/pulumi/pkg/v3@v3.70.2-0.20221116134521-f2775972e587/codegen/testing/test/testdata/simple-plain-schema/python/pulumi_example/component.py (about)

     1  # coding=utf-8
     2  # *** WARNING: this file was generated by test. ***
     3  # *** Do not edit by hand unless you're certain you know what you are doing! ***
     4  
     5  import copy
     6  import warnings
     7  import pulumi
     8  import pulumi.runtime
     9  from typing import Any, Mapping, Optional, Sequence, Union, overload
    10  from . import _utilities
    11  from . import outputs
    12  from ._inputs import *
    13  
    14  __all__ = ['ComponentArgs', 'Component']
    15  
    16  @pulumi.input_type
    17  class ComponentArgs:
    18      def __init__(__self__, *,
    19                   a: bool,
    20                   c: int,
    21                   e: str,
    22                   b: Optional[bool] = None,
    23                   bar: Optional['FooArgs'] = None,
    24                   baz: Optional[Sequence[pulumi.Input['FooArgs']]] = None,
    25                   baz_map: Optional[Mapping[str, pulumi.Input['FooArgs']]] = None,
    26                   d: Optional[int] = None,
    27                   f: Optional[str] = None,
    28                   foo: Optional[pulumi.Input['FooArgs']] = None):
    29          """
    30          The set of arguments for constructing a Component resource.
    31          """
    32          pulumi.set(__self__, "a", a)
    33          pulumi.set(__self__, "c", c)
    34          pulumi.set(__self__, "e", e)
    35          if b is not None:
    36              pulumi.set(__self__, "b", b)
    37          if bar is not None:
    38              pulumi.set(__self__, "bar", bar)
    39          if baz is not None:
    40              pulumi.set(__self__, "baz", baz)
    41          if baz_map is not None:
    42              pulumi.set(__self__, "baz_map", baz_map)
    43          if d is not None:
    44              pulumi.set(__self__, "d", d)
    45          if f is not None:
    46              pulumi.set(__self__, "f", f)
    47          if foo is not None:
    48              pulumi.set(__self__, "foo", foo)
    49  
    50      @property
    51      @pulumi.getter
    52      def a(self) -> bool:
    53          return pulumi.get(self, "a")
    54  
    55      @a.setter
    56      def a(self, value: bool):
    57          pulumi.set(self, "a", value)
    58  
    59      @property
    60      @pulumi.getter
    61      def c(self) -> int:
    62          return pulumi.get(self, "c")
    63  
    64      @c.setter
    65      def c(self, value: int):
    66          pulumi.set(self, "c", value)
    67  
    68      @property
    69      @pulumi.getter
    70      def e(self) -> str:
    71          return pulumi.get(self, "e")
    72  
    73      @e.setter
    74      def e(self, value: str):
    75          pulumi.set(self, "e", value)
    76  
    77      @property
    78      @pulumi.getter
    79      def b(self) -> Optional[bool]:
    80          return pulumi.get(self, "b")
    81  
    82      @b.setter
    83      def b(self, value: Optional[bool]):
    84          pulumi.set(self, "b", value)
    85  
    86      @property
    87      @pulumi.getter
    88      def bar(self) -> Optional['FooArgs']:
    89          return pulumi.get(self, "bar")
    90  
    91      @bar.setter
    92      def bar(self, value: Optional['FooArgs']):
    93          pulumi.set(self, "bar", value)
    94  
    95      @property
    96      @pulumi.getter
    97      def baz(self) -> Optional[Sequence[pulumi.Input['FooArgs']]]:
    98          return pulumi.get(self, "baz")
    99  
   100      @baz.setter
   101      def baz(self, value: Optional[Sequence[pulumi.Input['FooArgs']]]):
   102          pulumi.set(self, "baz", value)
   103  
   104      @property
   105      @pulumi.getter(name="bazMap")
   106      def baz_map(self) -> Optional[Mapping[str, pulumi.Input['FooArgs']]]:
   107          return pulumi.get(self, "baz_map")
   108  
   109      @baz_map.setter
   110      def baz_map(self, value: Optional[Mapping[str, pulumi.Input['FooArgs']]]):
   111          pulumi.set(self, "baz_map", value)
   112  
   113      @property
   114      @pulumi.getter
   115      def d(self) -> Optional[int]:
   116          return pulumi.get(self, "d")
   117  
   118      @d.setter
   119      def d(self, value: Optional[int]):
   120          pulumi.set(self, "d", value)
   121  
   122      @property
   123      @pulumi.getter
   124      def f(self) -> Optional[str]:
   125          return pulumi.get(self, "f")
   126  
   127      @f.setter
   128      def f(self, value: Optional[str]):
   129          pulumi.set(self, "f", value)
   130  
   131      @property
   132      @pulumi.getter
   133      def foo(self) -> Optional[pulumi.Input['FooArgs']]:
   134          return pulumi.get(self, "foo")
   135  
   136      @foo.setter
   137      def foo(self, value: Optional[pulumi.Input['FooArgs']]):
   138          pulumi.set(self, "foo", value)
   139  
   140  
   141  class Component(pulumi.ComponentResource):
   142      @overload
   143      def __init__(__self__,
   144                   resource_name: str,
   145                   opts: Optional[pulumi.ResourceOptions] = None,
   146                   a: Optional[bool] = None,
   147                   b: Optional[bool] = None,
   148                   bar: Optional[pulumi.InputType['FooArgs']] = None,
   149                   baz: Optional[Sequence[pulumi.Input[pulumi.InputType['FooArgs']]]] = None,
   150                   baz_map: Optional[Mapping[str, pulumi.Input[pulumi.InputType['FooArgs']]]] = None,
   151                   c: Optional[int] = None,
   152                   d: Optional[int] = None,
   153                   e: Optional[str] = None,
   154                   f: Optional[str] = None,
   155                   foo: Optional[pulumi.Input[pulumi.InputType['FooArgs']]] = None,
   156                   __props__=None):
   157          """
   158          Create a Component resource with the given unique name, props, and options.
   159          :param str resource_name: The name of the resource.
   160          :param pulumi.ResourceOptions opts: Options for the resource.
   161          """
   162          ...
   163      @overload
   164      def __init__(__self__,
   165                   resource_name: str,
   166                   args: ComponentArgs,
   167                   opts: Optional[pulumi.ResourceOptions] = None):
   168          """
   169          Create a Component resource with the given unique name, props, and options.
   170          :param str resource_name: The name of the resource.
   171          :param ComponentArgs args: The arguments to use to populate this resource's properties.
   172          :param pulumi.ResourceOptions opts: Options for the resource.
   173          """
   174          ...
   175      def __init__(__self__, resource_name: str, *args, **kwargs):
   176          resource_args, opts = _utilities.get_resource_args_opts(ComponentArgs, pulumi.ResourceOptions, *args, **kwargs)
   177          if resource_args is not None:
   178              __self__._internal_init(resource_name, opts, **resource_args.__dict__)
   179          else:
   180              __self__._internal_init(resource_name, *args, **kwargs)
   181  
   182      def _internal_init(__self__,
   183                   resource_name: str,
   184                   opts: Optional[pulumi.ResourceOptions] = None,
   185                   a: Optional[bool] = None,
   186                   b: Optional[bool] = None,
   187                   bar: Optional[pulumi.InputType['FooArgs']] = None,
   188                   baz: Optional[Sequence[pulumi.Input[pulumi.InputType['FooArgs']]]] = None,
   189                   baz_map: Optional[Mapping[str, pulumi.Input[pulumi.InputType['FooArgs']]]] = None,
   190                   c: Optional[int] = None,
   191                   d: Optional[int] = None,
   192                   e: Optional[str] = None,
   193                   f: Optional[str] = None,
   194                   foo: Optional[pulumi.Input[pulumi.InputType['FooArgs']]] = None,
   195                   __props__=None):
   196          opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
   197          if not isinstance(opts, pulumi.ResourceOptions):
   198              raise TypeError('Expected resource options to be a ResourceOptions instance')
   199          if opts.id is not None:
   200              raise ValueError('ComponentResource classes do not support opts.id')
   201          else:
   202              if __props__ is not None:
   203                  raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
   204              __props__ = ComponentArgs.__new__(ComponentArgs)
   205  
   206              if a is None and not opts.urn:
   207                  raise TypeError("Missing required property 'a'")
   208              __props__.__dict__["a"] = a
   209              __props__.__dict__["b"] = b
   210              __props__.__dict__["bar"] = bar
   211              __props__.__dict__["baz"] = baz
   212              __props__.__dict__["baz_map"] = baz_map
   213              if c is None and not opts.urn:
   214                  raise TypeError("Missing required property 'c'")
   215              __props__.__dict__["c"] = c
   216              __props__.__dict__["d"] = d
   217              if e is None and not opts.urn:
   218                  raise TypeError("Missing required property 'e'")
   219              __props__.__dict__["e"] = e
   220              __props__.__dict__["f"] = f
   221              __props__.__dict__["foo"] = foo
   222          super(Component, __self__).__init__(
   223              'example::Component',
   224              resource_name,
   225              __props__,
   226              opts,
   227              remote=True)
   228  
   229      @property
   230      @pulumi.getter
   231      def a(self) -> pulumi.Output[bool]:
   232          return pulumi.get(self, "a")
   233  
   234      @property
   235      @pulumi.getter
   236      def b(self) -> pulumi.Output[Optional[bool]]:
   237          return pulumi.get(self, "b")
   238  
   239      @property
   240      @pulumi.getter
   241      def bar(self) -> pulumi.Output[Optional['outputs.Foo']]:
   242          return pulumi.get(self, "bar")
   243  
   244      @property
   245      @pulumi.getter
   246      def baz(self) -> pulumi.Output[Optional[Sequence['outputs.Foo']]]:
   247          return pulumi.get(self, "baz")
   248  
   249      @property
   250      @pulumi.getter
   251      def c(self) -> pulumi.Output[int]:
   252          return pulumi.get(self, "c")
   253  
   254      @property
   255      @pulumi.getter
   256      def d(self) -> pulumi.Output[Optional[int]]:
   257          return pulumi.get(self, "d")
   258  
   259      @property
   260      @pulumi.getter
   261      def e(self) -> pulumi.Output[str]:
   262          return pulumi.get(self, "e")
   263  
   264      @property
   265      @pulumi.getter
   266      def f(self) -> pulumi.Output[Optional[str]]:
   267          return pulumi.get(self, "f")
   268  
   269      @property
   270      @pulumi.getter
   271      def foo(self) -> pulumi.Output[Optional['outputs.Foo']]:
   272          return pulumi.get(self, "foo")
   273