truss 0.11.12rc511__tar.gz → 0.11.12rc512__tar.gz

{truss-0.11.12rc511 → truss-0.11.12rc512}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: truss
-Version: 0.11.12rc511
+Version: 0.11.12rc512
 Summary: A seamless bridge from model development to model delivery
 Project-URL: Repository, https://github.com/basetenlabs/truss
 Project-URL: Homepage, https://truss.baseten.co

{truss-0.11.12rc511 → truss-0.11.12rc512}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "truss"
-version = "0.11.12rc511"
+version = "0.11.12rc512"
 description = "A seamless bridge from model development to model delivery"
 authors = [
     { name = "Pankaj Gupta", email = "no-reply@baseten.co" },

{truss-0.11.12rc511 → truss-0.11.12rc512}/truss/contexts/image_builder/serving_image_builder.py

@@ -760,7 +760,6 @@ class ServingImageBuilder(ImageBuilder):
                     user_id = config.docker_server.run_as_user_id
                 else:
                     user_id = 60000
-                # dockerfile_contents += f"\nENV APP_HOME=$HOME"
                 dockerfile_contents += f"\nCOPY --chown={user_id}:{user_id} ./bptr-manifest /static-bptr/static-bptr-manifest.json"
             docker_file_path = build_dir / MODEL_DOCKERFILE_NAME
             docker_file_path.write_text(dockerfile_contents)

{truss-0.11.12rc511 → truss-0.11.12rc512}/truss/templates/shared/lazy_data_resolver.py

@@ -1,6 +1,5 @@
 import atexit
 import logging
-import os
 import time
 from functools import lru_cache
 from pathlib import Path
@@ -14,10 +13,6 @@ LAZY_DATA_RESOLVER_PATH = [
     Path("/static-bptr/static-bptr-manifest.json"),
 ]
 
-# Add fallback for as-is deployments if HOME is set
-if os.environ.get("HOME"):
-    LAZY_DATA_RESOLVER_PATH.append(Path(os.environ.get("HOME")) / "bptr-manifest")
-
 MISSING_COLLECTION_MESSAGE = """model_cache: Data was not collected. Missing lazy_data_resolver.block_until_download_complete().
 This is a potential bug by the user implementation of model.py when using model_cache.
 We need you to call the block_until_download_complete() method during __init__ or load() method of your model.
@@ -53,18 +48,7 @@ class LazyDataResolverV2:
         self._lock = Lock()
         self._start_time = time.time()
         self.logger = logger or logging.getLogger(__name__)
-        
-        # Debug logging for bptr manifest detection
-        self.logger.info(f"LazyDataResolverV2: Checking for bptr manifest in paths: {LAZY_DATA_RESOLVER_PATH}")
-        bptr_found = self.bptr_exists()
-        self.logger.info(f"LazyDataResolverV2: bptr_exists() = {bptr_found}")
-        if bptr_found:
-            for path in LAZY_DATA_RESOLVER_PATH:
-                if path.exists():
-                    self.logger.info(f"LazyDataResolverV2: Found bptr manifest at {path}")
-                    break
-        
-        self._is_collected_by_user = not bptr_found
+        self._is_collected_by_user = not self.bptr_exists()
         thread = Thread(target=self._prefetch_in_thread, daemon=True)
         thread.start()
 
@@ -108,24 +92,13 @@ class LazyDataResolverV2:
     def _fetch(self) -> Union[str, Exception]:
         """cached and locked method to fetch the data."""
         if not self.bptr_exists():
-            self.logger.info("LazyDataResolverV2: No bptr manifest found, skipping download")
             return ""  # no data to resolve
-        
-        self.logger.info("LazyDataResolverV2: bptr manifest found, attempting to import truss_transfer")
-        try:
-            import truss_transfer
-            self.logger.info("LazyDataResolverV2: truss_transfer imported successfully")
-        except ImportError as e:
-            self.logger.error(f"LazyDataResolverV2: Failed to import truss_transfer: {e}")
-            return e
+        import truss_transfer
 
         try:
-            self.logger.info(f"LazyDataResolverV2: Calling truss_transfer.lazy_data_resolve with data_dir: {self._data_dir}")
-            result = truss_transfer.lazy_data_resolve(str(self._data_dir))
-            self.logger.info(f"LazyDataResolverV2: truss_transfer.lazy_data_resolve completed successfully")
-            return result
+            return truss_transfer.lazy_data_resolve(str(self._data_dir))
         except Exception as e:
-            self.logger.error(f"LazyDataResolverV2: Error occurred while fetching data: {e}")
+            self.logger.error(f"Error occurred while fetching data: {e}")
             return e
 
     def raise_if_not_collected(self):

truss-0.11.12rc511/baseten/.github/PULL_REQUEST_TEMPLATE/prod_deploy.md

@@ -1,3 +0,0 @@
-## BEFORE DEPLOY DO THESE THINGS
-- ensure the commit is **merge commit**
-- look at whats in the PR and make sure appropriate people are tagged for review

truss-0.11.12rc511/baseten/.github/pull_request_template.md

@@ -1,34 +0,0 @@
-<!--
-  What does this PR add, remove, and/or change?
--->
-## :rocket: What
-
-<!--
-  How was the change described above implemented?
--->
-## :computer: How
-
-<!--
-  How have I ensured release and ongoing quality of this change?
--->
-## :microscope: Testing
-
-<!--
-  For each of the categories of requirements, please specify what is required or write "none".
-
-  Pre-release requirements - Are there any changes need to be made or or rolled out before release of this PR?
-  - In most cases, before feature flags, Django fields, or internal APIs are deleted, all usages of them should be removed.
-  - Link to any PRs that need to be merged and fully deployed before this PR can be merged.
-
-  Post-release requirements - Does anything need to be changed or configured after this PR is merged for it to be fully rolled out?
-  - E.g. does a feature flag need to be enabled, a constance value updated, or a management command run?
-  - Please include *when* this should happen (e.g. immediately after a deploy, or are there other dependencies or tests that need to take place).
-  - Does this change require an image tag update?
-
-  External communication - Does this PR require a docs update, a changelog post, or reaching out to impacted customers?
--->
-## :ship: Release requirements
-
-- **Pre-release:** Specify here
-- **Post-release:** Specify here
-- **External communication:** Specify here

truss-0.11.12rc511/baseten/.proto/plugins/README.md

@@ -1,3 +0,0 @@
-## Proto plugins
-
-By placing all [plugins](https://moonrepo.dev/docs/proto/plugins) in the monorepo, we ensure improved security and easier maintenance for everyone involved.

truss-0.11.12rc511/baseten/3rd-party-apps/README.md

@@ -1,12 +0,0 @@
-# Purpose
-
-We need a way to build images off 3rd party repos but not necessarily forking their repos.
-Use this folder to host the configuration of the jobs and build/push from the GH action workflows.
-
-## How
-- Clone the 3rd party repo
-- Duplicate the files need to be modified
-- Modify the files
-- Run `diff -u` to generate patch file and place it under the `3rd-party-apps/<app-name>` folder (combine all patches into one file)
-- Create a `config.yaml` file in the folder
-- Create a patch file, make sure the patch level should be `-p0` 

truss-0.11.12rc511/baseten/README.md

@@ -1,109 +0,0 @@
-# Baseten Server
-
-## Initial setup
-
-See [instructions in the wiki](/docs/local-dev/Dev-setup.md)
-
-## Running everything
-
-To start all services, run the following script from the project root:
-
-```sh
-bin/run_everything.sh
-```
-
-You should now be able to access the baseten application at http://localhost:9090
-
-## Prediction with Beefeater and Django
-
-Django does not support calling model prediction directly. Instead, Beefeater acts as an intermediary:
-
-- It sends all non-predict requests to Django
-- When it receives a predict request, it calls Djangos `authz` endpoint to check if the user is allowed to make the request and if so calls the model in the minikube cluster.
-
-Here's a flowchart illustrating the process:
-
-```mermaid
-flowchart LR
-    client[Client]
-    beefeater[Beefeater]
-    django[Django]
-    minikube[Minikube Cluster]
-
-    client -->|:9090| beefeater
-    beefeater -->|proxies to :8000| django
-    beefeater -->|predict path| minikube
-    django -->|communicates with| minikube
-```
-
-## Running individual services
-See [bin/run_everything.sh](bin/run_everything.sh) for how we run each service in the project.
-
-### Running beefeater
-
-```sh
-cd ./go/beefeater
-make run-cs
-```
-
-### Running the frontend
-
-```sh
-npm run start
-```
-
-### Running the Django backend
-Run the backend, overriding the `HOST_URL` to point to the beefeater server:
-
-```sh
-HOST_URL=http://localhost:9090 uv run python manage.py runserver
-```
-
-You should now be able to access the baseten application at http://localhost:9090
-
-### Starting the operator
-
-See [operator/README.md](operator/README.md) for instructions on running the operator server locally.
-
-### Running celery
-
-See [docs/local-dev/how-to-run-celery-locally.md](docs/local-dev/how-to-run-celery-locally.md) for instructions on running celery locally.
-
-### Running the async request service
-
-See [async-request-service/README.md](async-request-service/README.md) for instructions on running the async request service locally.
-
-### Starting the kube event watcher
-
-To start the **kube-event-watcher**, run:
-
-```sh
-cd go/kube-watcher
-make build
-API_KEY=[your api key] HOST_URL=http://localhost:8000 ./event-watcher
-```
-
-The API used should be associated to a service account user. You can either change the super user to be one in billip or you create a service account user and an associated API key in `shell_plus`
-
-```
-service_user = User.objects.create(username="watcher_service_account", is_service_account=True, password="any password")
-UserAPIKey.objects.create_key(user=service_user, name="kube-watcher-api-key")
-```
-
-The kube-event-watcher does not yet support live reload. It must be restarted when the code changes
-
-## Testing
-In the project root, run:
-```
-pytest backend/path/to/test_file.py
-```
-
-Note: many tests use fixtures that are defined in `backend/conftest.py`
-
-## Pre-commit
-
-Install the pre-commit hooks by running `uv run pre-commit install` on project root.
-
-## More docs
-
-Find them under [/docs](docs).

truss-0.11.12rc511/baseten/access-training-buckets-lambda/README.md

@@ -1,9 +0,0 @@
-# Access Training Buckets
-
-NOTE: this is not a python package. The contents of this folder should not be imported in other python projects.
-
-The `lambda_function.py` is the function that is deployed to AWS Lambda that is used to enable creation and access of training buckets.
-
-It is deployed to lambda via zip, by running `zip -r lambda_function.zip lambda_function.py` and uploading to AWS Lambda.
-
-It relies on the role `TrainingCheckpointsLambda` which has the `LambdaGetOrCreateTrainingBucketAndRole` policy. 

truss-0.11.12rc511/baseten/async-request-service/README.md

@@ -1,194 +0,0 @@
-# Async request service
-
-Run the async request service. It runs on port 9001 by default:
-```
-make run-server
-```
-
-Run the request processor. It runs on port 9002 by default (for metrics and liveness probes):
-```
-make run-processor
-```
-
-Test:
-```
-moon run test
-```
-
-## Database
-This project uses [sqlalchemy](https://www.sqlalchemy.org/) as its ORM and [alembic](https://alembic.sqlalchemy.org/en/latest/) to manage DB migrations
-
-To setup the dev and test DBs. It will create the databases and apply the alembic migrations
-
-```
-make dev-db
-```
-
-### Make a new migrations
-If you change the tables definition, you will need to generate a new migration and apply it
-```
-alembic revision --autogenerate -m "describe you change here"
-
-alembic upgrade head
-```
-
-You can revert a migration by running
-```
-alembic downgrade -1
-```
-
-## Run async request service locally
-
-If running the async request service from VS Code (including in a codespace), you should add the `./async-request-service` folder as a separate VS Code workspace root. Open the command palette (Cmd + Shift + P) and select "Add folder to workspace", then navigate to the "async-request-service" folder.
-
-When you open a new VS Code terminal, you'll be asked which folder to use. To run the async request service, make sure you select the "async-request-service" folder. Then run:
-
-```
-uv sync
-```
-
-### Async request service API:
-```
-uv run python core/server.py --reload
-
-OR
-
-export DB_HOST=$(minikube ip)
-export DB_PORT=$(kubectl get service -n baseten baseten-postgres-np -o jsonpath={.spec.ports[0].nodePort})
-make run-server
-```
-
-### Queue processor:
-
-You'll first need a `DJANGO_API_KEY` to properly interface with your local Django server. You can get this by running the following command in your Django project:
-```
-uv run manage.py create_async_request_service_account --global
-```
-
-```
-uv run python core/processor_server.py
-
-OR
-
-export DB_HOST=$(minikube ip)
-export DB_PORT=$(kubectl get service -n baseten baseten-postgres-np -o jsonpath={.spec.ports[0].nodePort})
-export DJANGO_API_KEY=<api key outputted from running the above command>
-make run-processor
-```
-
-### Webhook server:
-In its own terminal, start the local_webhook_server:
-```
-make run-local-webhook
-```
-
-
-### Running tests locally:
-To run the tests locally, you'll need to set the `DB_HOST` and `DB_PORT` environment variables.
-```
-export DB_HOST=$(minikube ip)
-export DB_PORT=$(kubectl get service -n baseten baseten-postgres-np -o jsonpath={.spec.ports[0].nodePort})
-make test
-```
-After setting the environment variables, you can also run the tests manually:
-```
-uv run pytest tests/... # specify the test file or directory
-```
-
-### Sample request
-Run this in a different terminal using curl or any REST client you like. 
-Don't forget to use the localtunnel url in the 'webhook_endpoint' field.
-
-#### Running an async inference on a model deployment
-```
-curl --request POST \
-  --url http://localhost:9090/environments/production/async_predict \
-  --header "Authorization: Api-Key $BASETEN_API_KEY" \
-  --header 'Content-Type: application/json' \
-  --header 'Host: model-n4q95w5d.api.dev.baseten.co' \
-  --data '{
-	"model_input": "THIS IS SOME TEXT IN UPPER CASE SO I SEE IT IN LOGS EASILY",
-	"webhook_endpoint": "http://0.0.0.0:9003/webhook",
-	"max_time_in_queue_seconds": 100,
-	"inference_retry_config": {
-		"max_attempts": 3,
-		"initial_delay_ms": 1000,
-		"max_delay_ms": 5000
-	}
-}'
-```
-Getting async request status:
-```
-curl --request GET \
-  --url http://localhost:9090/async_request/653335653076454c8c76dc48f75d526d \
-  --header "Authorization: Api-Key $BASETEN_API_KEY" \
-  --header 'Host: model-n4q95w5d.api.dev.baseten.co'
-```
-
-#### Running an async inference on a chain deployment
-```
-curl --request POST \
-  --url http://localhost:9090/environments/production/async_run_remote \
-  --header "Authorization: Api-Key $BASETEN_API_KEY" \
-  --header 'Content-Type: application/json' \
-  --header 'Host: chain-n4q95w5d.api.dev.baseten.co' \
-  --data '{
-	"model_input": "THIS IS SOME TEXT IN UPPER CASE SO I SEE IT IN LOGS EASILY",
-	"webhook_endpoint": "http://0.0.0.0:9003/webhook"
-}'
-```
-Getting async request status:
-```
-curl --request GET \
-  --url http://localhost:9090/async_request/653335653076454c8c76dc48f75d526d \
-  --header "Authorization: Api-Key $BASETEN_API_KEY" \
-  --header 'Host: chain-n4q95w5d.api.dev.baseten.co'
-```
-
-## Testing on staging
-To test the end to end async request feature in staging, you'll need something to receive the webhook. This project comes with a very lightweight fastapi server to do just that. See `tests/local_webhook_server.py` for the details.
-
-You will also need something to forward the webhook requests from the queue-processor deployed on staging (or dev or prod) to you local machine. We recommend using [localtunnel](https://theboroer.github.io/localtunnel-www/), but you can use any tool you like to do this.
-
-Here is an example using `localtunnel` and the `local_webhook_server`
-```
-# install the localtunnel client
-> npm install -g localtunnel
-
-# In its own terminal, start localtunnel
-> lt --port 9003
-your url is: https://two-hairs-bake.loca.lt
-
-# In its own terminal, start the local_webhook_server
-> make run-local-webhook
-
-# In a different terminal using curl or any REST client you like
-# Don't forget to use the localtunnel url in the 'webhook_endpoint' field
-curl --request POST \
-  --url https://model-5wo8m73y.api.staging.baseten.co/environments/production/async_predict \
-  --header "Authorization: Api-Key $BASETEN_API_KEY" \
-  --header 'Content-Type: application/json' \
-  --data '{
-	"model_input": {"prompt":"cowboy riding of in the sunset"},
-	"webhook_endpoint": "https://two-hairs-bake.loca.lt/webhook",
-	"max_time_in_queue_seconds": 100,
-	"inference_retry_config": {
-		"max_attempts": 3,
-		"initial_delay_ms": 1000,
-		"max_delay_ms": 5000
-	}
-}'
-```
-
-## Tracing async requests
-Right now the async request service only supports propagating request traces to Beefeater's `/predict` endpoint. We do this so we can reuse the same async request ID as a trace ID throughout the async request lifecycle. This is important for debugging and monitoring purposes.
-
-This works as follows:
-1. When `/async_predict` is called, Beefeater creates a `request_id` and passes it to the async request service.
-2. When the async request service is ready to run the inference, it sends a request to Beefeater's `/predict` endpoint with the `request_id` included as the `trace_id` in the `traceparent` header. This allows Beefeater to associate the inference request with the original async request ID and trace it throughout its lifecycle.
-
-We use a couple of [OpenTelemetry-specific concepts](https://opentelemetry.io/docs/languages/python/cookbook/#manually-setting-span-context) to achieve this:
-1. A [`TracerProvider`](https://opentelemetry.io/docs/specs/otel/trace/api/#tracerprovider) is initialized once in the processor server, this will create a globally accessible `TracerProvider` object that can be used throughout the service to obtain tracers.
-2. A [`Tracer`](https://opentelemetry.io/docs/specs/otel/trace/api/#tracer) object is used to create spans for a request, right now we create one in the `beefeater_client`. This is where we create a span for the request to Beefeater's `/predict` endpoint.
-3. A [`SpanContext`](https://opentelemetry.io/docs/specs/otel/trace/api/#spancontext) object is created to specify the trace ID and span ID for a request. This is used to create the `traceparent` header that is propagated to Beefeater. We explicitly set the `trace_id` to the `request_id` so that we can trace the request throughout its lifecycle.
-4. We create a [`TraceContextTextMapPropagator` propagator](https://opentelemetry.io/docs/specs/otel/context/api-propagators/#propagator-types) that is used to create and inject a [`traceparent` header](https://www.w3.org/TR/trace-context/#traceparent-header) into the request. This is used to propagate the trace ID from the async request service to Beefeater.

truss-0.11.12rc511/baseten/backend/.venv.old/lib/python3.9/site-packages/Brotli-1.1.0.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-_brotli
-brotli

truss-0.11.12rc511/baseten/backend/.venv.old/lib/python3.9/site-packages/ConfigArgParse-1.7.dist-info/top_level.txt

@@ -1 +0,0 @@
-configargparse

truss-0.11.12rc511/baseten/backend/.venv.old/lib/python3.9/site-packages/Cython-0.29.37.dist-info/COPYING.txt

@@ -1,19 +0,0 @@
-The original Pyrex code as of 2006-04 is licensed under the following
-license: "Copyright stuff: Pyrex is free of restrictions. You may use,
-redistribute, modify and distribute modified versions."
-
-------------------
-
-Cython, which derives from Pyrex, is licensed under the Apache 2.0
-Software License.  More precisely, all modifications and new code
-made to go from Pyrex to Cython are so licensed.
-
-See LICENSE.txt for more details.
-
-------------------
-
-The output of a Cython compilation is NOT considered a derivative
-work of Cython.  Specifically, though the compilation process may
-embed snippets of varying lengths into the final output, these
-snippets, as embedded in the output, do not encumber the resulting
-output with any license restrictions.

truss-0.11.12rc511/baseten/backend/.venv.old/lib/python3.9/site-packages/Cython-0.29.37.dist-info/LICENSE.txt

@@ -1,176 +0,0 @@
-                                 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