crossplane-function-pythonic 0.0.6__py3-none-any.whl

crossplane_function_pythonic-0.0.6.dist-info/METADATA

@@ -0,0 +1,540 @@
+Metadata-Version: 2.4
+Name: crossplane-function-pythonic
+Version: 0.0.6
+Summary: A Python centric Crossplane Function
+Project-URL: Documentation, https://github.com/fortra/function-pythonic#readme
+Project-URL: Issues, https://github.com/fortra/function-pythonic/issues
+Project-URL: Source, https://github.com/fortra/function-pythonic
+Author-email: Patrick J McNerthney <pat@mcnerthney.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Requires-Dist: crossplane-function-sdk-python==0.9.0
+Requires-Dist: kopf==1.38.0
+Requires-Dist: pyyaml==6.0.2
+Description-Content-Type: text/markdown
+
+# function-pythonic
+
+## Introduction
+
+A Crossplane composition function that lets you compose Composites using a set
+of python classes enabling an elegant and terse syntax. Here is what the following
+example is doing:
+
+* Create an MR named 'vpc' with apiVersion 'ec2.aws.crossplane.io/v1beta1' and kind 'VPC'
+* Set the vpc region and cidr from the XR spec values
+* Set the XR status.vpcId to the created vpc id
+
+```yaml
+apiVersion: apiextensions.crossplane.io/v1
+kind: Composition
+metadata:
+  name: create-vpc
+spec:
+  compositeTypeRef:
+    apiVersion: example.crossplane.io/v1
+    kind: XR
+  mode: Pipeline
+  pipeline:
+  - step: 
+    functionRef:
+      name: function-pythonic
+    input:
+      apiVersion: pythonic.fn.crossplane.io/v1beta1
+      kind: Composite
+      composite: |
+        class Composite(BaseComposite):
+          def compose(self):
+            vpc = self.resources.vpc('ec2.aws.crossplane.io/v1beta1', 'VPC')
+            vpc.spec.forProvider.region = self.spec.region
+            vpc.spec.forProvider.cidrBlock = self.spec.cidr
+            self.status.vpcId = vpc.status.atProvider.vpcId
+```
+
+In addtion to an inline script, the python implementation can be specified
+as the complete path to a python class. Python packages can be deployed using
+ConfigMaps, enabling using your IDE of choice for writting the code. See
+[ConfigMap Packages](#configmap-packages) and
+[Filing System Packages](#filing-system-packages).
+
+## Examples
+
+In the [examples](./examples) directory are many exemples, including all of the
+function-go-templating examples implemented using function-pythonic.
+The [eks-cluster](./examples/eks-cluster/composition.yaml) example is a good
+complex example creating the entire vpc structure needed for an EKS cluster.
+
+## Installing function-pythonic
+
+```yaml
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-pythonic
+spec:
+  package: ghcr.io/fortra/function-pythonic:v0.0.7
+```
+
+## Composed Resource Dependencies
+
+function-pythonic automatically handles dependencies between composed resources.
+
+Just compose everything as if it is immediately created and the framework will delay
+the creation of any resources which depend on other resources which do not exist yet.
+In other words, it accomplishes what [function-sequencer](https://github.com/crossplane-contrib/function-sequencer)
+provides, but it automatically detects the dependencies.
+
+If a resource has been created and a dependency no longer exists due to some unexpected
+condition, the composition will be terminated or the observed value for that field will
+be used, depending on the `unknownsFatal` settings.
+
+Take the following example:
+```yaml
+vpc = self.resources.VPC('ec2.aws.crossplane.io/v1beta1', 'VPC')
+vpc.spec.forProvider.region = 'us-east-1
+vpc.spec.forProvider.cidrBlock = '10.0.0.0/16'
+
+subnet = self.resources.SubnetA('ec2.aws.crossplane.io/v1beta1', 'Subnet')
+subnet.spec.forProvider.region = 'us-east-1'
+subnet.spec.forProvider.vpcId = vpc.status.atProvider.vpcId
+subnet.spec.forProvider.availabilityZone = 'us-east-1a'
+subnet.spec.forProvider.cidrBlock = '10.0.0.0/20'
+```
+If the Subnet does not yet exist, the framework will detect if the vpcId set
+in the Subnet is unknown, and will delay the creation of the subnet.
+
+Once the Subnet has been created, if for some unexpected reason the vpcId passed
+to the Subnet is unknown, the framework will detect it and either terminate
+the Composite composition or use the vpcId in the observed Subnet. The default
+action taken is to fast fail by terminating the composition. This can be
+overridden for all composed resource by setting the Composite `self.unknownsFatal` field
+to False, or at the individual composed resource level by setting the
+`Resource.unknownsFatal` field to False.
+
+## Pythonic access of Protobuf Messages
+
+All Protobuf messages are wrapped by a set of python classes which enable using
+both object attribute names and dictionary key names to traverse the Protobuf
+message contents. For example, the following examples obtain the same value
+from the RunFunctionRequest message:
+```python
+region = request.observed.composite.resource.spec.region
+region = request['observed']['composite']['resource']['spec']['region']
+```
+Getting values from free form map and list values will not throw
+errors for keys that do not exist, but will return an unknown placeholder
+which evaluates as False. For example, the following will evaluate as False
+with a just created RunFunctionResponse message:
+```python
+vpcId = response.desired.resources.vpc.resource.status.atProvider.vpcId
+if vpcId:
+    # The vpcId is available
+```
+Note that maps or lists that do exist but do not have any members will evaluate
+as True, contrary to Python dicts and lists. Use the `len` function to test
+if the map or list exists and has members.
+
+When setting fields, all intermediary unknown placeholders will automatically
+be created. For example, this will create all items needed to set the
+region on the desired resource:
+```python
+response.desired.resources.vpc.resource.spec.forProvider.region = 'us-east-1'
+```
+Calling a message or map will clear it and will set any provided key word
+arguments. For example, this will either create or clear the resource
+and then set its apiVersion and kind:
+```python
+response.desired.resources.vpc.resource(apiVersion='ec2.aws.crossplane.io/v1beta1', kind='VPC')
+```
+The following functions are provided to create Protobuf structures:
+| Function | Description |
+| ----- | ----------- |
+| Map | Create a new Protobuf map |
+| List | Create a new Protobuf list |
+| Unknown | Create a new Protobuf unknown placeholder |
+| Yaml | Create a new Protobuf structure from a yaml string |
+| Json | Create a new Protobuf structure from a json string |
+| B64Encode | Encode a string into base 64 |
+| B64Decode | Decode a string from base 64 |
+
+The following items are supported in all the Protobuf Message wrapper classes: `bool`,
+`len`, `contains`, `iter`, `hash`, `==`, `str`, `format`
+
+To convert a Protobuf message to a string value, use either `str` or `format`.
+```python
+yaml  = str(request)                # get the request as yaml
+yaml  = format(request)             # also get the request as yaml
+yaml  = format(request, 'yaml')     # yet another get the request as yaml
+json  = format(request, 'json')     # get the request as json
+json  = format(request, 'jsonc')    # get the request as json compact
+proto = format(request, 'protobuf') # get the request as a protobuf string
+```
+## Composite Composition
+
+Composite composition is performed from a Composite orientation. A `BaseComposite` class
+is subclassed and the `compose` method is implemented.
+```python
+class Composite(BaseComposite):
+    def compose(self):
+        # Compose the Composite
+```
+The compose method can also declare itself as performing async io:
+```python
+class Composite(BaseComposite):
+    async def compose(self):
+        # Compose the Composite using async io when needed
+```
+
+### BaseComposite
+
+The BaseComposite class provides the following fields for manipulating the Composite itself:
+
+| Field | Type | Description |
+| ----- | ---- | ----------- |
+| self.observed | Map | Low level direct access to the observed composite |
+| self.desired | Map | Low level direct access to the desired composite |
+| self.apiVersion | String | The composite observed apiVersion |
+| self.kind | String | The composite observed kind |
+| self.metadata | Map | The composite observed metadata |
+| self.spec | Map | The composite observed spec |
+| self.status | Map | The composite desired and observed status, read from observed if not in desired |
+| self.conditions | Conditions | The composite desired and observed conditions, read from observed if not in desired |
+| self.connection | Connection | The composite desired and observed connection detials, read from observed if not in desired |
+| self.events | Events | Returned events against the Composite and optionally on the Claim |
+| self.ready | Boolean | The composite desired ready state |
+
+The BaseComposite also provides access to the following Crossplane Function level features:
+
+| Field | Type | Description |
+| ----- | ---- | ----------- |
+| self.request | Message | Low level direct access to the RunFunctionRequest message |
+| self.response | Message | Low level direct access to the RunFunctionResponse message |
+| self.logger | Logger | Python logger to log messages to the running function stdout |
+| self.ttl | Integer | Get or set the response TTL, in seconds |
+| self.credentials | Credentials | The request credentials |
+| self.context | Map | The response context, initialized from the request context |
+| self.environment | Map | The response environment, initialized from the request context environment |
+| self.requireds | Requireds | Request and read additional local Kubernetes resources |
+| self.resources | Resources | Define and process composed resources |
+| self.unknownsFatal | Boolean | Terminate the composition if already created resources are assigned unknown values, default True |
+| self.autoReady | Boolean | Perform auto ready processing on all composed resources, default True |
+
+### Composed Resources
+
+Creating and accessing composed resources is performed using the `BaseComposite.resources` field.
+`BaseComposite.resources` is a dictionary of the composed resources whose key is the composition
+resource name. The value returned when getting a resource from BaseComposite is the following
+Resource class:
+
+| Field | Type | Description |
+| ----- | ---- | ----------- |
+| Resource(apiVersion,kind,namespace,name) | Resource | Reset the resource and set the optional parameters |
+| Resource.name | String | The composition composed resource name |
+| Resource.observed | Map | Low level direct access to the observed composed resource |
+| Resource.desired | Map | Low level direct access to the desired composed resource |
+| Resource.apiVersion | String | The composed resource apiVersion |
+| Resource.kind | String | The composed resource kind |
+| Resource.externalName | String | The composed resource external name |
+| Resource.metadata | Map | The composed resource desired metadata |
+| Resource.spec | Map | The resource spec |
+| Resource.data | Map | The resource data |
+| Resource.status | Map | The resource status |
+| Resource.conditions | Conditions | The resource conditions |
+| Resource.connection | Connection | The resource connection details |
+| Resource.ready | Boolean | The resource ready state |
+| Resource.unknownsFatal | Boolean | Terminate the composition if this resource has been created and is assigned unknown values, default is Composite.unknownsFatal |
+| Resource.autoReady | Boolean | Perform auto ready processing on this resource, default is Composite.autoReady |
+
+### Required Resources (AKA Extra Resources)
+
+Creating and accessing required resources is performed using the `BaseComposite.requireds` field.
+`BaseComposite.requireds` is a dictionary of the required resources whose key is the required
+resource name. The value returned when getting a required resource from BaseComposite is the
+following RequiredResources class:
+
+| Field | Type | Description |
+| ----- | ---- | ----------- |
+| RequiredResource(apiVersion,kind,namespace,name,labels) | RequiredResource | Reset the required resource and set the optional parameters |
+| RequiredResources.name | String | The required resources name |
+| RequiredResources.apiVersion | String | The required resources apiVersion |
+| RequiredResources.kind | String | The required resources kind |
+| RequiredResources.namespace | String | The namespace to match when returning the required resources, see note below |
+| RequiredResources.matchName | String | The names to match when returning the required resources |
+| RequiredResources.matchLabels | Map | The labels to match when returning the required resources |
+
+The current version of crossplane-sdk-python used by function-pythonic does not support namespace
+selection. For now, use matchLabels and filter the results if required.
+
+RequiredResources acts like a Python list to provide access to the found required resources.
+Each resource in the list is the following RequiredResource class:
+
+| Field | Description |
+| ----- | ----------- |
+| RequiredResource.name | The required resource name |
+| RequiredResource.observed | Low level direct access to the observed required resource |
+| RequiredResource.apiVersion | The required resource apiVersion |
+| RequiredResource.kind | The required resource kind |
+| RequiredResource.metadata | The required resource metadata |
+| RequiredResource.spec | The required resource spec |
+| RequiredResource.data | The required resource data |
+| RequiredResource.status | The required resource status |
+| RequiredResource.conditions | The required resource conditions |
+
+### Conditions
+
+The `conditions` field is a map of the resource's status conditions array, with
+the map key being the condition type.
+
+| Field | Description |
+| ----- | ----------- |
+| Condition.type | The condtion type |
+| Condition.status | RequiredResource.observed | Low level direct access to the observed required resource |
+| RequiredResource.apiVersion | The required resource apiVersion |
+| RequiredResource.kind | The required resource kind |
+| RequiredResource.metadata | The required resource metadata |
+| RequiredResource.spec | The required resource spec |
+| RequiredResource.data | The required resource data |
+| RequiredResource.status | The required resource status |
+| RequiredResource.conditions | The required resource conditions |
+
+## Single use Composites
+
+Tired of creating a CompositeResourceDefinition, a Composition, and a Composite
+just to run that Composition once in a single use or initialize task?
+
+function-pythonic installs a `Composite` CompositeResourceDefinition that enables
+creating such tasks using a single Composite resource:
+```yaml
+apiVersion: pythonic.fortra.com/v1alpha1
+kind: Composite
+metadata:
+  name: composite-example
+spec:
+  composite: |
+    class Composite(BaseComposite):
+      def compose(self):
+        self.status.composite = 'Hello, World!'
+```
+
+## ConfigMap Packages
+
+ConfigMap based python packages are enable using the `--packages` and
+`--packages-namespace` command line options. ConfigMaps with the label
+`function-pythonic.package` will be incorporated in the python path at
+the location configured in the label value. For example, the following
+ConfigMap will enable python to use `import example.pythonic.features`
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  namespace: crossplane-system
+  name: example-pythonic
+  labels:
+    function-pythonic.package: example.pythonic
+data:
+  features.py: |
+    def anything():
+        return 'something'
+```
+Then, in your Composition:
+```yaml
+    ...
+    - step: pythonic
+    functionRef:
+      name: function-pythonic
+    input:
+      apiVersion: pythonic.fn.fortra.com/v1alpha1
+      kind: Composite
+      composite: |
+        from example.pythonic import features
+        class Composite(BaseComposite):
+            def compose(self):
+                anything = features.anything()
+    ...
+```
+The entire function-pythonic Composite class can be coded in the ConfigMap and
+only the complete Composite class path is needed in the step configuration.
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  namespace: crossplane-system
+  name: example-pythonic
+  labels:
+    function-pythonic.package: example.pythonic
+data:
+  features.py: |
+    from crossplane.pythonic import BaseComposite
+    class FeatureOneComposite(BaseComposite):
+        def compose(self):
+            # go at it!
+```
+```yaml
+    ...
+    - step: pythonic
+    functionRef:
+      name: function-pythonic
+    input:
+      apiVersion: pythonic.fn.fortra.com/v1alpha1
+      kind: Composite
+      composite: example.pythonic.features.FeatureOneComposite
+    ...
+```
+This requires enabling the the packages support using the `--packages` command
+line option in the DeploymentRuntimeConfig and configuring the required
+Kubernetes RBAC permissions. For example:
+```yaml
+apiVersion: pkg.crossplane.io/v1
+kind: Function
+metadata:
+  name: function-pythonic
+spec:
+  package: ghcr.io/fortra/function-pythonic:v0.0.7
+  runtimeConfigRef:
+    name: function-pythonic
+---
+apiVersion: pkg.crossplane.io/v1beta1
+kind: DeploymentRuntimeConfig
+metadata:
+  name: function-pythonic
+spec:
+  deploymentTemplate:
+    spec:
+      selector: {}
+      template:
+        spec:
+          containers:
+          - name: package-runtime
+            args:
+            - --debug
+            - --packages
+          serviceAccountName: function-pythonic
+  serviceAccountTemplate:
+    metadata:
+      name: function-pythonic
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: function-pythonic
+rules:
+- apiGroups:
+  - ''
+  resources:
+  - events
+  verbs:
+  - create
+- apiGroups:
+  - ''
+  resources:
+  - configmaps
+  verbs:
+  - list
+  - watch
+  - patch
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: function-pythonic
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: function-pythonic
+subjects:
+- kind: ServiceAccount
+  namespace: crossplane-system
+  name: function-pythonic
+```
+When enabled, labeled ConfigMaps are obtained cluster wide, requiring the above
+ClusterRole permissions. The `--packages-namespace` command line option will restrict
+to only using the supplied namespace. This option can be invoked multiple times.
+The above RBAC permission can then be per namespace RBAC Role permissions.
+
+Secrets can also be used in an identical manner as ConfigMaps by enabling the
+`--packages-secrets` command line option. Secrets permissions need to be
+added to the above RBAC configuration.
+
+## Filing System Packages
+
+Composition Composite implementations can be coded in a stand alone python files
+by configuring the function-pythonic deployment with the code mounted into
+the package-runtime container, and then adding the mount point to the python
+path using the --python-path command line option.
+```yaml
+apiVersion: pkg.crossplane.io/v1beta1
+kind: DeploymentRuntimeConfig
+metadata:
+  name: function-pythonic
+spec:
+  deploymentTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: package-runtime
+            args:
+            - --debug
+            - --python-path
+            - /mnt/composites
+            volumeMounts:
+            - name: composites
+              mountPath: /mnt/composites
+          volumes:
+          - name: composites
+            configMap:
+              name: pythonic-composites
+```
+See the [filing-system](examples/filing-system) example.
+
+## Install Additional Python Packages
+
+function-pythonic supports a `--pip-install` command line option which will run pip install
+with the configured pip install command. For example:
+```yaml
+apiVersion: pkg.crossplane.io/v1beta1
+kind: DeploymentRuntimeConfig
+metadata:
+  name: function-pythonic
+spec:
+  deploymentTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: package-runtime
+            args:
+            - --debug
+            - --pip-install
+            - --quiet aiobotocore==2.23.2
+```
+
+## Enable Oversize Protos
+
+The Protobuf python package used by function-pythonic limits the depth of yaml
+elements and the total size of yaml parsed. This results in a limit of approximately
+30 levels of nested yaml fields. This check can be disabled using the `--allow-oversize-protos`
+command line option. For example:
+
+```yaml
+apiVersion: pkg.crossplane.io/v1beta1
+kind: DeploymentRuntimeConfig
+metadata:
+  name: function-pythonic
+spec:
+  deploymentTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: package-runtime
+            args:
+            - --debug
+            - --allow-oversize-protos
+```

crossplane_function_pythonic-0.0.6.dist-info/RECORD

@@ -0,0 +1,5 @@
+crossplane_function_pythonic-0.0.6.dist-info/METADATA,sha256=JjVxNRwXVZNd1w_ejkK9zb4MiVjRlmcQmO6meaO_RzA,20687
+crossplane_function_pythonic-0.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crossplane_function_pythonic-0.0.6.dist-info/entry_points.txt,sha256=jJ4baywFDviB9WyAhyhNYF2VOCb6XtbRSjKf7bnBwhg,68
+crossplane_function_pythonic-0.0.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+crossplane_function_pythonic-0.0.6.dist-info/RECORD,,

crossplane_function_pythonic-0.0.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

crossplane_function_pythonic-0.0.6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+function-pythonic = crossplane.pythonic.main:main

crossplane_function_pythonic-0.0.6.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.