esd-services-api-client 2.4.0__tar.gz → 2.5.0__tar.gz

{esd_services_api_client-2.4.0 → esd_services_api_client-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esd-services-api-client
-Version: 2.4.0
+Version: 2.5.0
 Summary: Python clients for ESD services
 Home-page: https://github.com/SneaksAndData/esd-services-api-client
 License: Apache 2.0
@@ -16,11 +16,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Provides-Extra: azure
 Provides-Extra: nexus
-Requires-Dist: adapta[azure,datadog,storage] (>=3.0,<4.0)
+Requires-Dist: adapta[azure,datadog,storage] (>=3.2,<4.0)
 Requires-Dist: azure-identity (>=1.7,<1.8) ; extra == "azure"
 Requires-Dist: dataclasses-json (>=0.6.0,<0.7.0)
-Requires-Dist: httpx (>=0.26.0,<0.27.0) ; extra == "nexus"
-Requires-Dist: injector (>=0.21.0,<0.22.0) ; extra == "nexus"
+Requires-Dist: httpx (>=0.27.0,<0.28.0) ; extra == "nexus"
+Requires-Dist: injector (>=0.22.0,<0.23.0) ; extra == "nexus"
 Requires-Dist: pycryptodome (>=3.15,<3.16)
 Requires-Dist: pyjwt (>=2.4.0,<2.5.0)
 Project-URL: Repository, https://github.com/SneaksAndData/esd-services-api-client

esd_services_api_client-2.5.0/esd_services_api_client/__init__.py

@@ -0,0 +1,20 @@
+#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#
+#  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.
+#
+
+"""
+ Root index.
+"""
+
+__version__ = "2.5.0"

{esd_services_api_client-2.4.0 → esd_services_api_client-2.5.0}/esd_services_api_client/nexus/README.md

@@ -1,3 +1,5 @@
+from pandas import DataFramefrom pandas import DataFramefrom pandas import DataFrame
+
 ## Nexus
 Set the following environment variables for Azure:
 ```
@@ -42,14 +44,7 @@ from esd_services_api_client.nexus.algorithms import MinimalisticAlgorithm
 from esd_services_api_client.nexus.input import InputReader, InputProcessor
 
 from esd_services_api_client.nexus.input.payload_reader import AlgorithmPayload
-
-
-async def my_on_complete_func_1(**kwargs):
-    pass
-
-
-async def my_on_complete_func_2(**kwargs):
-    pass
+from esd_services_api_client.nexus.telemetry.user_telemetry_recorder import UserTelemetryRecorder, UserTelemetry
 
 
 @dataclass
@@ -81,10 +76,10 @@ class MockRequestHandler(BaseHTTPRequestHandler):
     """
 
     def __init__(
-        self,
-        request: bytes,
-        client_address: tuple[str, int],
-        server: socketserver.BaseServer,
+            self,
+            request: bytes,
+            client_address: tuple[str, int],
+            server: socketserver.BaseServer,
     ):
         """
          Initialize request handler
@@ -130,14 +125,14 @@ class MockRequestHandler(BaseHTTPRequestHandler):
 class XReader(InputReader[MyAlgorithmPayload, pandas.DataFrame]):
     @inject
     def __init__(
-        self,
-        store: QueryEnabledStore,
-        metrics_provider: MetricsProvider,
-        logger_factory: LoggerFactory,
-        payload: MyAlgorithmPayload,
-        socket_provider: ExternalSocketProvider,
-        *readers: "InputReader",
-        cache: InputCache
+            self,
+            store: QueryEnabledStore,
+            metrics_provider: MetricsProvider,
+            logger_factory: LoggerFactory,
+            payload: MyAlgorithmPayload,
+            socket_provider: ExternalSocketProvider,
+            *readers: "InputReader",
+            cache: InputCache
     ):
         super().__init__(
             socket=socket_provider.socket("x"),
@@ -161,14 +156,14 @@ class XReader(InputReader[MyAlgorithmPayload, pandas.DataFrame]):
 class YReader(InputReader[MyAlgorithmPayload2, pandas.DataFrame]):
     @inject
     def __init__(
-        self,
-        store: QueryEnabledStore,
-        metrics_provider: MetricsProvider,
-        logger_factory: LoggerFactory,
-        payload: MyAlgorithmPayload2,
-        socket_provider: ExternalSocketProvider,
-        *readers: "InputReader",
-        cache: InputCache
+            self,
+            store: QueryEnabledStore,
+            metrics_provider: MetricsProvider,
+            logger_factory: LoggerFactory,
+            payload: MyAlgorithmPayload2,
+            socket_provider: ExternalSocketProvider,
+            *readers: "InputReader",
+            cache: InputCache
     ):
         super().__init__(
             socket=socket_provider.socket("y"),
@@ -192,12 +187,12 @@ class YReader(InputReader[MyAlgorithmPayload2, pandas.DataFrame]):
 class XProcessor(InputProcessor[MyAlgorithmPayload, pandas.DataFrame]):
     @inject
     def __init__(
-        self,
-        x: XReader,
-        metrics_provider: MetricsProvider,
-        logger_factory: LoggerFactory,
-        my_conf: MyAlgorithmConfiguration,
-        cache: InputCache,
+            self,
+            x: XReader,
+            metrics_provider: MetricsProvider,
+            logger_factory: LoggerFactory,
+            my_conf: MyAlgorithmConfiguration,
+            cache: InputCache,
     ):
         super().__init__(
             x,
@@ -210,7 +205,7 @@ class XProcessor(InputProcessor[MyAlgorithmPayload, pandas.DataFrame]):
         self.conf = my_conf
 
     async def _process_input(
-        self, x: pandas.DataFrame, **_
+            self, x: pandas.DataFrame, **_
     ) -> pandas.DataFrame:
         self._logger.info("Config: {config}", config=self.conf.to_json())
         return x.assign(c=[-1, 1])
@@ -219,12 +214,12 @@ class XProcessor(InputProcessor[MyAlgorithmPayload, pandas.DataFrame]):
 class YProcessor(InputProcessor[MyAlgorithmPayload, pandas.DataFrame]):
     @inject
     def __init__(
-        self,
-        y: YReader,
-        metrics_provider: MetricsProvider,
-        logger_factory: LoggerFactory,
-        my_conf: MyAlgorithmConfiguration,
-        cache: InputCache,
+            self,
+            y: YReader,
+            metrics_provider: MetricsProvider,
+            logger_factory: LoggerFactory,
+            my_conf: MyAlgorithmConfiguration,
+            cache: InputCache,
     ):
         super().__init__(
             y,
@@ -237,7 +232,7 @@ class YProcessor(InputProcessor[MyAlgorithmPayload, pandas.DataFrame]):
         self.conf = my_conf
 
     async def _process_input(
-        self, y: pandas.DataFrame, **_
+            self, y: pandas.DataFrame, **_
     ) -> pandas.DataFrame:
         self._logger.info("Config: {config}", config=self.conf.to_json())
         return y.assign(c=[-1, 1])
@@ -264,23 +259,34 @@ class MyAlgorithm(MinimalisticAlgorithm[MyAlgorithmPayload]):
 
     @inject
     def __init__(
-        self,
-        metrics_provider: MetricsProvider,
-        logger_factory: LoggerFactory,
-        x_processor: XProcessor,
-        y_processor: YProcessor,
-        cache: InputCache,
+            self,
+            metrics_provider: MetricsProvider,
+            logger_factory: LoggerFactory,
+            x_processor: XProcessor,
+            y_processor: YProcessor,
+            cache: InputCache,
     ):
         super().__init__(
             metrics_provider, logger_factory, x_processor, y_processor, cache=cache
         )
 
     async def _run(
-        self, x: pandas.DataFrame, y: pandas.DataFrame, **kwargs
+            self, x: pandas.DataFrame, y: pandas.DataFrame, **kwargs
     ) -> MyResult:
         return MyResult(x, y)
 
 
+class ObjectiveAnalytics(UserTelemetryRecorder):
+
+    async def _compute(self, 
+                       algorithm_payload: 
+                       AlgorithmPayload, 
+                       algorithm_result: AlgorithmResult, 
+                       run_id: str, 
+                       **inputs: pandas.DataFrame) -> UserTelemetry:
+        pass
+
+
 async def main():
     """
      Mock HTTP Server
@@ -297,6 +303,7 @@ async def main():
             .use_processor(XProcessor)
             .use_processor(YProcessor)
             .use_algorithm(MyAlgorithm)
+            .on_complete(ObjectiveAnalytics)
             .inject_configuration(MyAlgorithmConfiguration)
             .inject_payload(MyAlgorithmPayload, MyAlgorithmPayload2)
         )

{esd_services_api_client-2.4.0 → esd_services_api_client-2.5.0}/esd_services_api_client/nexus/abstractions/nexus_object.py

@@ -90,13 +90,13 @@ class NexusCoreObject(ABC):
 
 class NexusObject(Generic[TPayload, TResult], NexusCoreObject, ABC):
     """
-    Base class for all Nexus objects.
+    Base class for all Nexus objects that perform operations on the algorithm payload.
     """
 
     @classmethod
     def alias(cls) -> str:
         """
-        Alias to identify this reader's output
+        Alias to identify this class instances when passed through kwargs.
         """
         return snakecase(
             re.sub(

{esd_services_api_client-2.4.0 → esd_services_api_client-2.5.0}/esd_services_api_client/nexus/core/app_core.py

@@ -23,11 +23,12 @@ import platform
 import signal
 import sys
 import traceback
-from typing import final, Type, Optional, Coroutine
+from typing import final, Type, Optional
 
 import backoff
 import urllib3.exceptions
 import azure.core.exceptions
+from adapta.logs import LoggerInterface
 from adapta.process_communication import DataSocket
 from adapta.storage.blob.base import StorageClient
 from adapta.storage.query_enabled_store import QueryEnabledStore
@@ -41,6 +42,7 @@ from esd_services_api_client.crystal import (
     AlgorithmRunResult,
     CrystalEntrypointArguments,
 )
+from esd_services_api_client.nexus.abstractions.logger_factory import LoggerFactory
 from esd_services_api_client.nexus.abstractions.nexus_object import AlgorithmResult
 from esd_services_api_client.nexus.algorithms import (
     BaselineAlgorithm,
@@ -61,6 +63,10 @@ from esd_services_api_client.nexus.input.payload_reader import (
     AlgorithmPayload,
 )
 from esd_services_api_client.nexus.telemetry.recorder import TelemetryRecorder
+from esd_services_api_client.nexus.telemetry.user_telemetry_recorder import (
+    UserTelemetryRecorder,
+)
+from esd_services_api_client import __version__
 
 
 def is_transient_exception(exception: Optional[BaseException]) -> Optional[bool]:
@@ -112,7 +118,7 @@ class Nexus:
         self._algorithm_class: Optional[Type[BaselineAlgorithm]] = None
         self._run_args = args
         self._algorithm_run_task: Optional[asyncio.Task] = None
-        self._on_complete_tasks: list[Coroutine] = []
+        self._on_complete_tasks: list[type[UserTelemetryRecorder]] = []
 
         attach_signal_handlers()
 
@@ -123,11 +129,11 @@ class Nexus:
         """
         return self._algorithm_class
 
-    def on_complete(self, coro: Coroutine) -> "Nexus":
+    def on_complete(self, *post_processors: type[UserTelemetryRecorder]) -> "Nexus":
         """
         Attaches a coroutine to run on algorithm completion.
         """
-        self._on_complete_tasks.append(coro)
+        self._on_complete_tasks.extend(post_processors)
         return self
 
     def add_reader(self, reader: Type[InputReader]) -> "Nexus":
@@ -254,6 +260,15 @@ class Nexus:
 
         algorithm: BaselineAlgorithm = self._injector.get(self._algorithm_class)
         telemetry_recorder: TelemetryRecorder = self._injector.get(TelemetryRecorder)
+        root_logger: LoggerInterface = self._injector.get(LoggerFactory).create_logger(
+            logger_type=self.__class__,
+        )
+
+        root_logger.info(
+            "Running algorithm {algorithm} on Nexus version {version}",
+            algorithm=algorithm.__class__.__name__,
+            version=__version__,
+        )
 
         async with algorithm as instance:
             self._algorithm_run_task = asyncio.create_task(
@@ -261,23 +276,47 @@ class Nexus:
             )
             await self._algorithm_run_task
             ex = self._algorithm_run_task.exception()
-            on_complete_tasks = [
-                asyncio.create_task(on_complete_task)
-                for on_complete_task in self._on_complete_tasks
-            ]
 
             await self._submit_result(
                 self._algorithm_run_task.result() if not ex else None,
                 self._algorithm_run_task.exception(),
             )
-            if len(on_complete_tasks) > 0:
-                await asyncio.wait(on_complete_tasks)
 
             # record telemetry
+            root_logger.info(
+                "Recording telemetry for the run {request_id}",
+                request_id=self._run_args.request_id,
+            )
             async with telemetry_recorder as recorder:
                 await recorder.record(
                     run_id=self._run_args.request_id, **algorithm.inputs
                 )
+                on_complete_tasks = [
+                    recorder.record_user_telemetry(
+                        user_recorder_type=on_complete_task_class,
+                        run_id=self._run_args.request_id,
+                        result=self._algorithm_run_task.result(),
+                        **algorithm.inputs,
+                    )
+                    for on_complete_task_class in self._on_complete_tasks
+                ]
+                if len(on_complete_tasks) > 0:
+                    done, pending = await asyncio.wait(on_complete_tasks)
+                    if len(pending) > 0:
+                        root_logger.warning(
+                            "Some post-processing operations did not complete or failed. Please review application logs for more information"
+                        )
+                    for done_on_complete_task in done:
+                        on_complete_task_exc = done_on_complete_task.exception()
+                        if on_complete_task_exc:
+                            root_logger.warning(
+                                "Post processing task failed",
+                                exception=on_complete_task_exc,
+                            )
+                else:
+                    root_logger.info(
+                        "No post processing tasks were defined for this run."
+                    )
 
             # dispose of QES instance gracefully as it might hold open connections
             qes = self._injector.get(QueryEnabledStore)

{esd_services_api_client-2.4.0 → esd_services_api_client-2.5.0}/esd_services_api_client/nexus/telemetry/recorder.py

@@ -3,20 +3,27 @@
 """
 import asyncio
 import os
+from asyncio import Task
 from functools import partial
 from typing import final
 
-import pandas as pd
+from pandas import DataFrame
 from adapta.metrics import MetricsProvider
 from adapta.process_communication import DataSocket
 from adapta.storage.blob.base import StorageClient
 from injector import inject, singleton
 
 from esd_services_api_client.nexus.abstractions.logger_factory import LoggerFactory
-from esd_services_api_client.nexus.abstractions.nexus_object import NexusCoreObject
+from esd_services_api_client.nexus.abstractions.nexus_object import (
+    NexusCoreObject,
+    AlgorithmResult,
+)
 from esd_services_api_client.nexus.core.serializers import (
     TelemetrySerializer,
 )
+from esd_services_api_client.nexus.telemetry.user_telemetry_recorder import (
+    UserTelemetryRecorder,
+)
 
 
 @final
@@ -51,7 +58,7 @@ class TelemetryRecorder(NexusCoreObject):
         """
 
         async def _record(
-            entity_to_record: pd.DataFrame | dict,
+            entity_to_record: DataFrame | dict,
             entity_name: str,
             **_,
         ) -> None:
@@ -61,7 +68,7 @@ class TelemetryRecorder(NexusCoreObject):
                 run_id=run_id,
             )
             if not isinstance(entity_to_record, dict) and not isinstance(
-                entity_to_record, pd.DataFrame
+                entity_to_record, DataFrame
             ):
                 self._logger.warning(
                     "Unsupported data type: {telemetry_entity_type}. Telemetry recording skipped.",
@@ -72,7 +79,13 @@ class TelemetryRecorder(NexusCoreObject):
                     data=entity_to_record,
                     blob_path=DataSocket(
                         alias="telemetry",
-                        data_path=f"{self._telemetry_base_path}/{entity_name}/{run_id}",
+                        data_path=os.path.join(
+                            self._telemetry_base_path,
+                            "telemetry_group=inputs",
+                            f"entity_name={entity_name}",
+                            f"request_id={run_id}",
+                            run_id,
+                        ),
                         data_format="null",
                     ).parse_data_path(),
                     serialization_format=self._serializer.get_serialization_format(
@@ -106,3 +119,29 @@ class TelemetryRecorder(NexusCoreObject):
                 self._logger.warning(
                     "Telemetry recoding failed", exception=telemetry_exc
                 )
+
+    def record_user_telemetry(
+        self,
+        user_recorder_type: type[UserTelemetryRecorder],
+        run_id: str,
+        result: AlgorithmResult,
+        **inputs: DataFrame,
+    ) -> Task:
+        """
+        Creates an awaitable task that records user telemetry using provided recorder type.
+
+        :param user_recorder_type: Recorder type to record user telemetry.
+        :param run_id: The request_id to record user telemetry for.
+        :param result: Result of the algorithm.
+        :param inputs: Algorithm input data.
+        """
+        return asyncio.create_task(
+            user_recorder_type(
+                run_id=run_id,
+                metrics_provider=self._metrics_provider,
+                logger=self._logger,
+                storage_client=self._storage_client,
+                serializer=self._serializer,
+                telemetry_base_path=self._telemetry_base_path,
+            ).record(run_id=run_id, algorithm_result=result, **inputs)
+        )

esd_services_api_client-2.5.0/esd_services_api_client/nexus/telemetry/user_telemetry_recorder.py

@@ -0,0 +1,168 @@
+"""
+ User-defined telemetry.
+"""
+import os.path
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from functools import partial
+from typing import final
+
+from pandas import DataFrame
+
+from adapta.process_communication import DataSocket
+from adapta.storage.blob.base import StorageClient
+from adapta.logs import LoggerInterface
+from adapta.metrics import MetricsProvider
+from adapta.utils.decorators import run_time_metrics_async
+from dataclasses_json.stringcase import snakecase
+from injector import inject
+
+from esd_services_api_client.nexus.abstractions.nexus_object import AlgorithmResult
+from esd_services_api_client.nexus.core.serializers import TelemetrySerializer
+from esd_services_api_client.nexus.input.payload_reader import AlgorithmPayload
+
+
+@final
+@dataclass
+class UserTelemetryPathSegment:
+    """
+    Path segment for user telemetry.
+    """
+
+    segment: str
+    segment_header: str
+
+    def __str__(self):
+        return "=".join([self.segment_header, self.segment])
+
+
+@final
+class UserTelemetry:
+    """
+    Base class for user-defined telemetry types.
+    """
+
+    def __init__(
+        self, telemetry: DataFrame, *telemetry_path_segments: UserTelemetryPathSegment
+    ):
+        self._telemetry = telemetry
+        self._telemetry_path_segments = telemetry_path_segments
+
+    @property
+    def telemetry(self) -> DataFrame:
+        """
+        User telemetry data
+        """
+        return self._telemetry
+
+    @property
+    def telemetry_path(self) -> str:
+        """
+        Path segment for user telemetry data to include when writing it out.
+        """
+        if len(self._telemetry_path_segments) == 0:
+            return ""
+        return "/".join([str(t_path) for t_path in self._telemetry_path_segments])
+
+
+class UserTelemetryRecorder(ABC):
+    """
+    Base class for user-defined telemetry recorders.
+    """
+
+    @inject
+    def __init__(
+        self,
+        algorithm_payload: AlgorithmPayload,
+        metrics_provider: MetricsProvider,
+        logger: LoggerInterface,
+        storage_client: StorageClient,
+        serializer: TelemetrySerializer,
+        telemetry_base_path: str,
+    ):
+        self._metrics_provider = metrics_provider
+        self._logger = logger
+        self._payload = algorithm_payload
+        self._storage_client = storage_client
+        self._serializer = serializer
+        self._telemetry_base_path = telemetry_base_path
+
+    @property
+    def _metric_tags(self) -> dict[str, str]:
+        return {"recorder": self.__class__.alias().upper()}
+
+    @abstractmethod
+    async def _compute(
+        self,
+        algorithm_payload: AlgorithmPayload,
+        algorithm_result: AlgorithmResult,
+        run_id: str,
+        **inputs: DataFrame,
+    ) -> UserTelemetry:
+        """
+        Produces the dataframe to record as user-level telemetry data.
+        """
+
+    async def record(
+        self, algorithm_result: AlgorithmResult, run_id: str, **inputs: DataFrame
+    ):
+        """
+        Record user-defined telemetry data.
+        """
+
+        @run_time_metrics_async(
+            metric_name="user_telemetry_recording",
+            on_finish_message_template="Finished recording telemetry from {recorder} in {elapsed:.2f}s seconds",
+            template_args={
+                "recorder": self.__class__.alias().upper(),
+            },
+        )
+        async def _measured_recording(**run_args) -> UserTelemetry:
+            return await self._compute(**run_args)
+
+        telemetry: UserTelemetry = await partial(
+            _measured_recording,
+            **(
+                {
+                    "algorithm_payload": self._payload,
+                    "algorithm_result": algorithm_result,
+                    "run_id": run_id,
+                }
+                | inputs
+            ),
+            metric_tags=self._metric_tags,
+            metrics_provider=self._metrics_provider,
+            logger=self._logger,
+        )()
+
+        self._storage_client.save_data_as_blob(
+            data=telemetry.telemetry,
+            blob_path=DataSocket(
+                alias="user_telemetry",
+                data_path=os.path.join(
+                    self._telemetry_base_path,
+                    "telemetry_group=user",
+                    f"recorder_class={self.__class__.alias()}",
+                    telemetry.telemetry_path,  # path join eliminates empty segments
+                    f"request_id={run_id}",
+                    run_id,
+                ),
+                data_format="null",
+            ).parse_data_path(),
+            serialization_format=self._serializer.get_serialization_format(telemetry),
+            overwrite=True,
+        )
+
+    @classmethod
+    def alias(cls) -> str:
+        """
+        Alias to identify this recorder in logging and metrics data.
+        """
+        return snakecase(
+            re.sub(
+                r"(?<!^)(?=[A-Z])",
+                "_",
+                cls.__name__.lower(),
+            )
+        )

{esd_services_api_client-2.4.0 → esd_services_api_client-2.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "esd-services-api-client"
-version = "2.4.0"
+version = "2.5.0"
 description = "Python clients for ESD services"
 authors = ["ECCO Sneaks & Data <esdsupport@ecco.com>"]
 maintainers = ['GZU <gzu@ecco.com>', 'JRB <ext-jrb@ecco.com>', 'VISA <visa@ecco.com>']
@@ -10,19 +10,19 @@ repository = 'https://github.com/SneaksAndData/esd-services-api-client'
 
 [tool.poetry.dependencies]
 python = ">=3.9,<3.12"
-adapta = { version = "^3.0", extras = ["azure", "storage", "datadog"] }
+adapta = { version = "^3.2", extras = ["azure", "storage", "datadog"] }
 dataclasses-json = "^0.6.0"
 pycryptodome = "~3.15"
 azure-identity = { version = "~1.7", optional = true }
-injector = { version = "~0.21.0", optional = true }
-httpx = { version = "^0.26.0", optional = true }
+injector = { version = "~0.22.0", optional = true }
+httpx = { version = "^0.27.0", optional = true }
 pyjwt = "~2.4.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2"
-pylint = "^2.12"
+pylint = "^3"
 pytest-mock = "^3.6.1"
-pytest-cov = "^2.12"
+pytest-cov = "^3"
 requests = "^2.27"
 cryptography = "~36.0"
 requests-mock = "^1.10"

esd_services_api_client-2.4.0/esd_services_api_client/_version.py

@@ -1 +0,0 @@
-__version__ = '2.4.0'

esd_services_api_client-2.4.0/esd_services_api_client/common/__init__.py

@@ -1,14 +0,0 @@
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
-#
-#  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.
-#