tracdap-runtime 0.8.0b1__py3-none-any.whl → 0.8.0b3__py3-none-any.whl

tracdap/rt/_impl/core/__init__.py

@@ -0,0 +1,14 @@
+#  Licensed to the Fintech Open Source Foundation (FINOS) under one or
+#  more contributor license agreements. See the NOTICE file distributed
+#  with this work for additional information regarding copyright ownership.
+#  FINOS licenses this file to you 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.

tracdap/rt/_impl/{config_parser.py → core/config_parser.py}

@@ -12,8 +12,14 @@
 #  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.
-
-from __future__ import annotations
+#
+#      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.
 
 import dataclasses as _dc
 import decimal
@@ -32,7 +38,8 @@ import tracdap.rt.config as _config
 import tracdap.rt.exceptions as _ex
 import tracdap.rt.ext.plugins as _plugins
 import tracdap.rt.ext.config as _config_ext
-import tracdap.rt._impl.util as _util
+import tracdap.rt._impl.core.logging as _logging
+import tracdap.rt._impl.core.util as _util
 
 import yaml
 import yaml.parser
@@ -43,7 +50,7 @@ _T = tp.TypeVar('_T')
 class ConfigManager:
 
     @classmethod
-    def for_root_config(cls, root_config_file: tp.Union[str, pathlib.Path, None]) -> ConfigManager:
+    def for_root_config(cls, root_config_file: tp.Union[str, pathlib.Path, None]) -> "ConfigManager":
 
         if isinstance(root_config_file, pathlib.Path):
             root_file_path = cls._resolve_scheme(root_config_file)
@@ -69,7 +76,7 @@ class ConfigManager:
             return ConfigManager(working_dir_url, None)
 
     @classmethod
-    def for_root_dir(cls, root_config_dir: tp.Union[str, pathlib.Path]) -> ConfigManager:
+    def for_root_dir(cls, root_config_dir: tp.Union[str, pathlib.Path]) -> "ConfigManager":
 
         if isinstance(root_config_dir, pathlib.Path):
             root_dir_path = cls._resolve_scheme(root_config_dir)
@@ -103,7 +110,7 @@ class ConfigManager:
             return raw_url
 
     def __init__(self, root_dir_url: _urlp.ParseResult, root_file_url: tp.Optional[_urlp.ParseResult]):
-        self._log = _util.logger_for_object(self)
+        self._log = _logging.logger_for_object(self)
         self._root_dir_url = root_dir_url
         self._root_file_url = root_file_url
 
@@ -294,7 +301,7 @@ class ConfigParser(tp.Generic[_T]):
     }
 
     def __init__(self, config_class: _T.__class__, dev_mode_locations: tp.List[str] = None):
-        self._log = _util.logger_for_object(self)
+        self._log = _logging.logger_for_object(self)
         self._config_class = config_class
         self._dev_mode_locations = dev_mode_locations or []
         self._errors = []

tracdap/rt/_impl/{data.py → core/data.py}

@@ -37,7 +37,7 @@ except ModuleNotFoundError:
 import tracdap.rt.api.experimental as _api
 import tracdap.rt.metadata as _meta
 import tracdap.rt.exceptions as _ex
-import tracdap.rt._impl.util as _util
+import tracdap.rt._impl.core.logging as _log
 
 
 @dc.dataclass(frozen=True)
@@ -188,7 +188,7 @@ class DataMapping:
     :py:class:`TypeMapping <tracdap.rt.impl.type_system.MetadataCodec>`.
     """
 
-    __log = _util.logger_for_namespace(_DataInternal.__module__ + ".DataMapping")
+    __log = _log.logger_for_namespace(_DataInternal.__module__ + ".DataMapping")
 
     # Matches TRAC_ARROW_TYPE_MAPPING in ArrowSchema, tracdap-lib-data
 
@@ -715,7 +715,7 @@ class DataConformance:
     Check and/or apply conformance between datasets and schemas.
     """
 
-    __log = _util.logger_for_namespace(_DataInternal.__module__ + ".DataConformance")
+    __log = _log.logger_for_namespace(_DataInternal.__module__ + ".DataConformance")
 
     __E_FIELD_MISSING = \
         "Field [{field_name}] is missing from the data"

tracdap/rt/_impl/core/logging.py

@@ -0,0 +1,195 @@
+#  Licensed to the Fintech Open Source Foundation (FINOS) under one or
+#  more contributor license agreements. See the NOTICE file distributed
+#  with this work for additional information regarding copyright ownership.
+#  FINOS licenses this file to you 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.
+
+import io as _io
+import sys as _sys
+import typing as _tp
+
+from logging import *
+
+
+class PlainFormatter(Formatter):
+
+    FORMAT = f"%(asctime)s [%(threadName)s] %(levelname)s %(name)s" + \
+                     f" - %(message)s"
+
+    def __init__(self):
+        super().__init__(self.FORMAT)
+
+
+class ColorFormatter(Formatter):
+
+    _BLACK, _RED, _GREEN, _YELLOW, _BLUE, _MAGENTA, _CYAN, _WHITE, _DEFAULT_WHITE = range(9)
+    _DARK_BASE = 30
+    _LIGHT_BASE = 90
+
+    # DARK_BASE + WHITE = light grey
+    # DARK_BASE + DEFAULT_WHITE = regular console white
+    # LIGHT_BASE + WHITE = bright white (0xffffff), very bright!
+
+    def __init__(self, is_bright: bool):
+
+        super().__init__(self._base_fmt(is_bright))
+        self._level_colors = self._make_level_colors(is_bright)
+        self._default_color = self._make_default_color(is_bright)
+
+    def format(self, record):
+
+        level_name = record.levelname
+        level_color = self._level_colors.get(level_name)
+
+        if level_color:
+            record.levelname = level_color
+        else:
+            record.levelname = self._default_color + level_name
+
+        return Formatter.format(self, record)
+
+    def _base_fmt(self, is_bright: bool):
+
+        if is_bright:
+            base_color = self._make_ansi_code(self._DARK_BASE, self._DEFAULT_WHITE, is_bold=False)
+            message_color = self._make_ansi_code(self._LIGHT_BASE, self._CYAN, is_bold=False)
+        else:
+            base_color = self._make_ansi_code(self._DARK_BASE, self._WHITE, is_bold=False)
+            message_color = self._make_ansi_code(self._DARK_BASE, self._CYAN, is_bold=False)
+
+        return f"{base_color}%(asctime)s [%(threadName)s] %(levelname)s{base_color} %(name)s" + \
+            f" - {message_color}%(message)s"
+
+    def _make_level_colors(self, is_bright: bool):
+
+        base_code = self._LIGHT_BASE if is_bright else self._DARK_BASE
+
+        green = self._make_ansi_code(base_code, self._GREEN, is_bold=is_bright)
+        yellow = self._make_ansi_code(base_code, self._YELLOW, is_bold=is_bright)
+        red = self._make_ansi_code(base_code, self._RED, is_bold=is_bright)
+
+        level_colors = {
+            'CRITICAL': f"{red}CRITICAL",
+            'ERROR': f"{red}ERROR",
+            'WARNING': f"{yellow}WARNING",
+            'INFO': f"{green}INFO"
+        }
+
+        return level_colors
+
+    def _make_default_color(self, is_bright: bool):
+
+        base_code = self._LIGHT_BASE if is_bright else self._DARK_BASE
+        blue = self._make_ansi_code(base_code, self._BLUE, is_bold=is_bright)
+
+        return blue
+
+    @classmethod
+    def _make_ansi_code(cls, base_code: int, color_offset: int, is_bold: bool):
+        return f"\033[{1 if is_bold else 0};{base_code + color_offset}m"
+
+
+def configure_logging(enable_debug=False):
+
+    root_logger = getLogger()
+    log_level = DEBUG if enable_debug else INFO
+
+    if not root_logger.hasHandlers():
+
+        console_formatter = ColorFormatter(is_bright=True)
+        console_handler = StreamHandler(_sys.stdout)
+        console_handler.setFormatter(console_formatter)
+        console_handler.setLevel(INFO)
+        root_logger.addHandler(console_handler)
+        root_logger.setLevel(log_level)
+
+        # Use is_bright=False for logs from the TRAC runtime, so model logs stand out
+
+        trac_logger = getLogger("tracdap.rt")
+
+        console_formatter = ColorFormatter(is_bright=False)
+        console_handler = StreamHandler(_sys.stdout)
+        console_handler.setFormatter(console_formatter)
+        console_handler.setLevel(log_level)
+        trac_logger.addHandler(console_handler)
+        trac_logger.propagate = False
+
+
+def logger_for_object(obj: object) -> Logger:
+    return logger_for_class(obj.__class__)
+
+
+def logger_for_class(clazz: type) -> Logger:
+    qualified_class_name = f"{clazz.__module__}.{clazz.__name__}"
+    return getLogger(qualified_class_name)
+
+
+def logger_for_namespace(namespace: str) -> Logger:
+    return getLogger(namespace)
+
+
+class JobLogger(Logger):
+
+    def __init__(self, sys_log: Logger, *handlers: Handler):
+
+        super().__init__(sys_log.name, sys_log.level)
+        self._sys_log = sys_log._log
+        self._job_log = super()._log
+
+        for handler in handlers:
+            self.addHandler(handler)
+
+    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False, stacklevel=1):
+
+        self._sys_log(level, msg, args, exc_info, extra, stack_info, stacklevel)
+        self._job_log(level, msg, args, exc_info, extra, stack_info, stacklevel)
+
+
+class LogProvider:
+
+    def logger_for_object(self, obj: object) -> Logger:
+        return logger_for_object(obj)
+
+    def logger_for_class(self, clazz: type) -> Logger:
+        return logger_for_class(clazz)
+
+    def logger_for_namespace(self, namespace: str) -> Logger:
+        return logger_for_namespace(namespace)
+
+
+class JobLogProvider(LogProvider):
+
+    def __init__(self, *handlers: Handler):
+        self.__handlers = handlers
+
+    def logger_for_object(self, obj: object) -> Logger:
+        base_logger = logger_for_object(obj)
+        return JobLogger(base_logger, *self.__handlers)
+
+    def logger_for_class(self, clazz: type) -> Logger:
+        base_logger = logger_for_class(clazz)
+        return JobLogger(base_logger, *self.__handlers)
+
+    def logger_for_namespace(self, namespace: str) -> Logger:
+        base_logger = logger_for_namespace(namespace)
+        return JobLogger(base_logger, *self.__handlers)
+
+
+def job_log_provider(target: _tp.BinaryIO) -> JobLogProvider:
+
+    stream = _io.TextIOWrapper(target, newline="\r\n")
+    formatter = PlainFormatter()
+
+    handler = StreamHandler(stream)
+    handler.setFormatter(formatter)
+
+    return JobLogProvider(handler)

tracdap/rt/_impl/{models.py → core/models.py}

@@ -25,11 +25,12 @@ import tracdap.rt.metadata as _meta
 import tracdap.rt.config as _cfg
 import tracdap.rt.exceptions as _ex
 
-import tracdap.rt._impl.type_system as _types
-import tracdap.rt._impl.repos as _repos
-import tracdap.rt._impl.shim as _shim
-import tracdap.rt._impl.util as _util
-import tracdap.rt._impl.validation as _val
+import tracdap.rt._impl.core.logging as _logging
+import tracdap.rt._impl.core.repos as _repos
+import tracdap.rt._impl.core.shim as _shim
+import tracdap.rt._impl.core.type_system as _types
+import tracdap.rt._impl.core.util as _util
+import tracdap.rt._impl.core.validation as _val
 
 
 class ModelLoader:
@@ -43,7 +44,7 @@ class ModelLoader:
 
     def __init__(self, sys_config: _cfg.RuntimeConfig, scratch_dir: pathlib.Path):
 
-        self.__log = _util.logger_for_object(self)
+        self.__log = _logging.logger_for_object(self)
 
         self.__scratch_dir = scratch_dir.joinpath("models")
         self.__repos = _repos.RepositoryManager(sys_config)

tracdap/rt/_impl/{repos.py → core/repos.py}

@@ -13,10 +13,12 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import typing as _tp
+
 import tracdap.rt.ext.plugins as plugins
 import tracdap.rt.config as cfg
 import tracdap.rt.exceptions as ex
-import tracdap.rt._impl.util as util
+import tracdap.rt._impl.core.logging as _logging
 
 # Import repo interfaces
 from tracdap.rt.ext.repos import *
@@ -26,8 +28,8 @@ class RepositoryManager:
 
     def __init__(self, sys_config: cfg.RuntimeConfig):
 
-        self._log = util.logger_for_object(self)
-        self._repos: tp.Dict[str, IModelRepository] = dict()
+        self._log = _logging.logger_for_object(self)
+        self._repos: _tp.Dict[str, IModelRepository] = dict()
 
         # Initialize all repos in the system config
         # Any errors for missing repo types (plugins) will be raised during startup

tracdap/rt/_impl/{schemas.py → core/schemas.py}

@@ -21,10 +21,10 @@ import pyarrow as pa
 
 import tracdap.rt.metadata as _meta
 import tracdap.rt.exceptions as _ex
-import tracdap.rt._impl.data as _data
-import tracdap.rt._impl.storage as _storage
-import tracdap.rt._impl.shim as _shim
-import tracdap.rt._impl.util as _util
+import tracdap.rt._impl.core.data as _data
+import tracdap.rt._impl.core.logging as _log
+import tracdap.rt._impl.core.storage as _storage
+import tracdap.rt._impl.core.shim as _shim
 
 
 class SchemaLoader:
@@ -169,4 +169,4 @@ class SchemaLoader:
         raise _ex.EDataConformance(err)
 
 
-SchemaLoader._log = _util.logger_for_class(SchemaLoader)
+SchemaLoader._log = _log.logger_for_class(SchemaLoader)

tracdap/rt/_impl/{shim.py → core/shim.py}

@@ -30,8 +30,9 @@ import importlib.machinery as _ilm
 import importlib.resources as _ilr
 
 import tracdap.rt.exceptions as _ex
-import tracdap.rt._impl.guard_rails as _guard
-import tracdap.rt._impl.util as _util
+import tracdap.rt._impl.core.guard_rails as _guard
+import tracdap.rt._impl.core.logging as _log
+import tracdap.rt._impl.core.util as _util
 
 
 class _Shim:
@@ -138,7 +139,7 @@ class _NamespaceShimFinder(_ila.MetaPathFinder):
     def __init__(self, shim_map: tp.Dict[str, _Shim], active_shim: _ActiveShim):
         self.__shim_map = shim_map
         self.__active_shim = active_shim
-        self._log = _util.logger_for_class(ShimLoader)
+        self._log = _log.logger_for_class(ShimLoader)
 
     def find_spec(
             self, fullname: str,
@@ -561,5 +562,5 @@ class ShimLoader:
                 raise _ex.ERuntimeValidation(err)
 
 
-ShimLoader._log = _util.logger_for_class(ShimLoader)
+ShimLoader._log = _log.logger_for_class(ShimLoader)
 ShimLoader._init()  # noqa

tracdap/rt/_impl/{storage.py → core/storage.py}

@@ -29,9 +29,10 @@ import tracdap.rt.metadata as _meta
 import tracdap.rt.config as _cfg
 import tracdap.rt.exceptions as _ex
 import tracdap.rt.ext.plugins as plugins
-import tracdap.rt._impl.data as _data
-import tracdap.rt._impl.util as _util
-import tracdap.rt._impl.validation as _val
+import tracdap.rt._impl.core.data as _data
+import tracdap.rt._impl.core.logging as _logging
+import tracdap.rt._impl.core.util as _util
+import tracdap.rt._impl.core.validation as _val
 
 # Import storage interfaces (using the internal version, it has extra bits that are not public)
 from tracdap.rt._impl.ext.storage import *
@@ -76,7 +77,7 @@ class StorageManager:
 
     def __init__(self, sys_config: _cfg.RuntimeConfig):
 
-        self.__log = _util.logger_for_object(self)
+        self.__log = _logging.logger_for_object(self)
         self.__file_storage: tp.Dict[str, IFileStorage] = dict()
         self.__data_storage: tp.Dict[str, IDataStorage] = dict()
         self.__external: tp.List[str] = list()
@@ -224,7 +225,7 @@ class CommonFileStorage(IFileStorage):
 
     def __init__(self, storage_key: str, storage_config: _cfg.PluginConfig, fs: pa_fs.SubTreeFileSystem):
 
-        self._log = _util.logger_for_object(self)
+        self._log = _logging.logger_for_object(self)
         self._key = storage_key
         self._config = storage_config
         self._fs = fs
@@ -731,7 +732,7 @@ class CommonDataStorage(IDataStorage):
             self, config: _cfg.PluginConfig, file_storage: IFileStorage,
             pushdown_pandas: bool = False, pushdown_spark: bool = False):
 
-        self.__log = _util.logger_for_object(self)
+        self.__log = _logging.logger_for_object(self)
 
         self.__config = config
         self.__file_storage = file_storage

tracdap/rt/_impl/{util.py → core/util.py}

@@ -14,11 +14,9 @@
 #  limitations under the License.
 
 import datetime as dt
-import logging
 import pathlib
 import platform
 
-import sys
 import typing as tp
 import uuid
 
@@ -38,114 +36,6 @@ def is_windows():
     return __IS_WINDOWS
 
 
-class ColorFormatter(logging.Formatter):
-
-    _BLACK, _RED, _GREEN, _YELLOW, _BLUE, _MAGENTA, _CYAN, _WHITE, _DEFAULT_WHITE = range(9)
-    _DARK_BASE = 30
-    _LIGHT_BASE = 90
-
-    # DARK_BASE + WHITE = light grey
-    # DARK_BASE + DEFAULT_WHITE = regular console white
-    # LIGHT_BASE + WHITE = bright white (0xffffff), very bright!
-
-    def __init__(self, is_bright: bool):
-
-        super().__init__(self._base_fmt(is_bright))
-        self._level_colors = self._make_level_colors(is_bright)
-        self._default_color = self._make_default_color(is_bright)
-
-    def format(self, record):
-
-        level_name = record.levelname
-        level_color = self._level_colors.get(level_name)
-
-        if level_color:
-            record.levelname = level_color
-        else:
-            record.levelname = self._default_color + level_name
-
-        return logging.Formatter.format(self, record)
-
-    def _base_fmt(self, is_bright: bool):
-
-        if is_bright:
-            base_color = self._make_ansi_code(self._DARK_BASE, self._DEFAULT_WHITE, is_bold=False)
-            message_color = self._make_ansi_code(self._LIGHT_BASE, self._CYAN, is_bold=False)
-        else:
-            base_color = self._make_ansi_code(self._DARK_BASE, self._WHITE, is_bold=False)
-            message_color = self._make_ansi_code(self._DARK_BASE, self._CYAN, is_bold=False)
-
-        return f"{base_color}%(asctime)s [%(threadName)s] %(levelname)s{base_color} %(name)s" + \
-               f" - {message_color}%(message)s"
-
-    def _make_level_colors(self, is_bright: bool):
-
-        base_code = self._LIGHT_BASE if is_bright else self._DARK_BASE
-
-        green = self._make_ansi_code(base_code, self._GREEN, is_bold=is_bright)
-        yellow = self._make_ansi_code(base_code, self._YELLOW, is_bold=is_bright)
-        red = self._make_ansi_code(base_code, self._RED, is_bold=is_bright)
-
-        level_colors = {
-            'CRITICAL': f"{red}CRITICAL",
-            'ERROR': f"{red}ERROR",
-            'WARNING': f"{yellow}WARNING",
-            'INFO': f"{green}INFO"
-        }
-
-        return level_colors
-
-    def _make_default_color(self, is_bright: bool):
-
-        base_code = self._LIGHT_BASE if is_bright else self._DARK_BASE
-        blue = self._make_ansi_code(base_code, self._BLUE, is_bold=is_bright)
-
-        return blue
-
-    @classmethod
-    def _make_ansi_code(cls, base_code: int, color_offset: int, is_bold: bool):
-        return f"\033[{1 if is_bold else 0};{base_code + color_offset}m"
-
-
-def configure_logging(enable_debug=False):
-
-    root_logger = logging.getLogger()
-    log_level = logging.DEBUG if enable_debug else logging.INFO
-
-    if not root_logger.hasHandlers():
-
-        console_formatter = ColorFormatter(is_bright=True)
-        console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setFormatter(console_formatter)
-        console_handler.setLevel(logging.INFO)
-        root_logger.addHandler(console_handler)
-        root_logger.setLevel(log_level)
-
-        # Use is_bright=False for logs from the TRAC runtime, so model logs stand out
-
-        trac_logger = logging.getLogger("tracdap.rt")
-
-        console_formatter = ColorFormatter(is_bright=False)
-        console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setFormatter(console_formatter)
-        console_handler.setLevel(log_level)
-        trac_logger.addHandler(console_handler)
-        trac_logger.propagate = False
-
-
-def logger_for_object(obj: object) -> logging.Logger:
-    return logger_for_class(obj.__class__)
-
-
-def logger_for_class(clazz: type) -> logging.Logger:
-    qualified_class_name = f"{clazz.__module__}.{clazz.__name__}"
-    return logging.getLogger(qualified_class_name)
-
-
-def logger_for_namespace(namespace: str) -> logging.Logger:
-    return logging.getLogger(namespace)
-
-
 def format_file_size(size: int) -> str:
 
     if size < 1024:

tracdap/rt/_impl/{validation.py → core/validation.py}

@@ -22,7 +22,8 @@ import pathlib
 
 import tracdap.rt.metadata as meta
 import tracdap.rt.exceptions as ex
-import tracdap.rt._impl.util as util
+import tracdap.rt._impl.core.logging as log
+import tracdap.rt._impl.core.util as util
 
 # _Named placeholder type from API hook is needed for API type checking
 from tracdap.rt.api.hook import _Named  # noqa
@@ -74,7 +75,7 @@ class _TypeValidator:
     # Inspecting a function signature can take ~ half a second in Python 3.7
     __method_cache: tp.Dict[str, tp.Tuple[inspect.Signature, tp.Any]] = dict()
 
-    _log: logging.Logger = util.logger_for_namespace(__name__)
+    _log: logging.Logger = log.logger_for_namespace(__name__)
 
     @classmethod
     def validate_signature(cls, method: tp.Callable, *args, **kwargs):
@@ -324,7 +325,7 @@ class StaticValidator:
         meta.BasicType.INTEGER,
         meta.BasicType.DATE]
 
-    _log: logging.Logger = util.logger_for_namespace(__name__)
+    _log: logging.Logger = log.logger_for_namespace(__name__)
 
     @classmethod
     def is_primitive_type(cls, basic_type: meta.BasicType) -> bool:

tracdap/rt/_impl/exec/__init__.py

@@ -0,0 +1,14 @@
+#  Licensed to the Fintech Open Source Foundation (FINOS) under one or
+#  more contributor license agreements. See the NOTICE file distributed
+#  with this work for additional information regarding copyright ownership.
+#  FINOS licenses this file to you 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.