fameio 1.8.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

fameio/source/writer.py

@@ -1,14 +1,18 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import logging as log
-import os.path
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, List, Union
 
-import pandas as pd
-from fameio.source.logs import log_error_and_raise
+from fameprotobuf.DataStorage_pb2 import DataStorage
+from fameprotobuf.InputFile_pb2 import InputData
+from fameprotobuf.Field_pb2 import NestedField
+from fameprotobuf.Contract_pb2 import ProtoContract
+from fameprotobuf.Model_pb2 import ModelData
+
+from fameio.source.logs import log_error_and_raise, log
+from fameio.source.results.reader import Reader
 from fameio.source.scenario import (
     Agent,
     Attribute,
@@ -16,12 +20,12 @@ from fameio.source.scenario import (
     GeneralProperties,
     Scenario,
 )
-from fameio.source.path_resolver import PathResolver
+from fameio.source.schema import Schema
 from fameio.source.schema.attribute import AttributeSpecs, AttributeType
+from fameio.source.schema.java_packages import JavaPackages
 from fameio.source.series import TimeSeriesManager
-from fameio.source.time import START_IN_REAL_TIME, ConversionException, FameTime
+from fameio.source.time import FameTime
 from fameio.source.tools import ensure_is_list
-from fameprotobuf import DataStorage_pb2
 
 
 class ProtoWriterException(Exception):
@@ -33,107 +37,107 @@ class ProtoWriterException(Exception):
 class ProtoWriter:
     """Writes a given scenario to protobuf file"""
 
+    _FAME_PROTOBUF_STREAM_HEADER = "famecoreprotobufstreamfilev001"  # noqa
+
     _TYPE_NOT_IMPLEMENTED = "AttributeType '{}' not implemented."
-    _NOT_TIME_SERIES = "Cannot convert value '{}' to TimeSeries."
     _CONTRACT_UNSUPPORTED = (
         "Unsupported value for Contract Attribute '{}'; "
         "Only support `int`, `float`, `enum` or `dict` types are supported here."
     )
     _USING_DEFAULT = "Using provided Default for Attribute: '{}'."
-    _CORRUPT_TIME_SERIES_VALUE = "TimeSeries file '{}' is corrupt: At least one entry in value column is not numeric."
-    _CORRUPT_TIME_SERIES_KEY = "TimeSeries file '{}' is corrupt: At least one entry in first column is not a timestamp."
-    _TIME_SERIES_FILE_NOT_FOUND = "Cannot find TimeSeries file '{}'."
     _NO_FILE_SPECIFIED = "Could not write to '{}'. Please specify a valid output file."
 
-    def __init__(self, file_path: Path, path_resolver=PathResolver()) -> None:
-        self.file_path = file_path
-        self.time_series_manager = TimeSeriesManager()
-        self._path_resolver = path_resolver
+    _INFO_WRITING = "Writing scenario to protobuf file `{}`"
+    _INFO_WRITING_COMPLETED = "Saved protobuf file `{}` to disk"
+
+    def __init__(self, file_path: Path, time_series_manager: TimeSeriesManager) -> None:
+        self.file_path: Path = file_path
+        self._time_series_manager: TimeSeriesManager = time_series_manager
 
     def write_validated_scenario(self, scenario: Scenario) -> None:
         """Writes given validated Scenario to file"""
-        log.info("Writing scenario to protobuf file `{}`".format(self.file_path))
-        pb_data_storage = DataStorage_pb2.DataStorage()
-        pb_input = pb_data_storage.input
-
-        log.info("Adding General Properties")
-        ProtoWriter._set_general_properties(pb_input, scenario.general_properties)
-
-        log.info("Adding Agents")
-        schema = scenario.schema
-        for agent in scenario.agents:
-            pb_agent = ProtoWriter._set_agent(pb_input.agent.add(), agent)
-            attribute_specs = schema.agent_types[agent.type_name].attributes
-            self._set_attributes(pb_agent, agent.attributes, attribute_specs)
+        pb_data_storage = self._create_protobuf_from_scenario(scenario)
+        self._write_protobuf_to_disk(pb_data_storage)
 
-        log.info("Adding Contracts")
-        for contract in scenario.contracts:
-            pb_contract = ProtoWriter._set_contract(pb_input.contract.add(), contract)
-            ProtoWriter._set_contract_attributes(pb_contract, contract.attributes)
+    def _create_protobuf_from_scenario(self, scenario: Scenario) -> DataStorage:
+        """Returns given `scenario` written to new DataStorage protobuf"""
+        log().info("Converting scenario to protobuf.")
+        pb_data_storage = DataStorage()
+        pb_input = pb_data_storage.input
 
-        log.info("Adding TimeSeries")
+        self._set_general_properties(pb_input, scenario.general_properties)
+        self._add_agents(pb_input, scenario.agents, scenario.schema)
+        self._add_contracts(pb_input, scenario.contracts)
         self._set_time_series(pb_input)
-        log.info("Writing to disk")
-        self._write_protobuf_to_disk(pb_data_storage)
+        self._set_schema(pb_input, scenario.schema)
+
+        self._set_java_package_names(pb_data_storage.model, scenario.schema.packages)
+        return pb_data_storage
 
     @staticmethod
-    def _set_general_properties(pb_input, gen_props: GeneralProperties) -> None:
-        """Saves Scenario's general properties to specified protobuf `pb_input` container"""
-        pb_input.runId = gen_props.run_id
-        pb_input.simulation.startTime = gen_props.simulation_start_time
-        pb_input.simulation.stopTime = gen_props.simulation_stop_time
-        pb_input.simulation.randomSeed = gen_props.simulation_random_seed
-        pb_input.output.interval = gen_props.output_interval
-        pb_input.output.process = gen_props.output_process
+    def _set_general_properties(pb_input: InputData, general_properties: GeneralProperties) -> None:
+        """Saves a scenario's general properties to specified protobuf `pb_input` container"""
+        log().info("Adding General Properties")
+        pb_input.runId = general_properties.run_id
+        pb_input.simulation.startTime = general_properties.simulation_start_time
+        pb_input.simulation.stopTime = general_properties.simulation_stop_time
+        pb_input.simulation.randomSeed = general_properties.simulation_random_seed
+        pb_input.output.interval = general_properties.output_interval
+        pb_input.output.process = general_properties.output_process
+
+    def _add_agents(self, pb_input: InputData, agents: List[Agent], schema: Schema) -> None:
+        """Triggers setting of `agents` to `pb_input`"""
+        log().info("Adding Agents")
+        for agent in agents:
+            pb_agent = self._set_agent(pb_input.agent.add(), agent)
+            attribute_specs = schema.agent_types[agent.type_name].attributes
+            self._set_attributes(pb_agent, agent.attributes, attribute_specs)
+            pb_agent.metadata = repr(agent.meta_data)
 
     @staticmethod
-    def _set_agent(pb_agent, agent: Agent):
-        """Saves type and id of given `agent` to protobuf `pb_agent` container. Returns given `pb_agent`."""
+    def _set_agent(pb_agent: InputData.AgentDao, agent: Agent) -> InputData.AgentDao:
+        """Saves type and id of given `agent` to protobuf `pb_agent` container. Returns given `pb_agent`"""
         pb_agent.className = agent.type_name
         pb_agent.id = agent.id
         return pb_agent
 
     def _set_attributes(
         self,
-        pb_parent,
+        pb_parent: Union[InputData.AgentDao, NestedField],
         attributes: Dict[str, Attribute],
         specs: Dict[str, AttributeSpecs],
     ) -> None:
         """Assigns `attributes` to protobuf fields of given `pb_parent` - cascades for nested Attributes"""
         values_not_set = [key for key in specs.keys()]
         for name, attribute in attributes.items():
-            pb_field = ProtoWriter._add_field(pb_parent, name)
+            pb_field = self._add_field(pb_parent, name)
             attribute_specs = specs[name]
             values_not_set.remove(name)
             attribute_type = attribute_specs.attr_type
             if attribute_type is AttributeType.BLOCK:
                 if attribute_specs.is_list:
                     for index, entry in enumerate(attribute.nested_list):
-                        pb_inner = ProtoWriter._add_field(pb_field, str(index))
+                        pb_inner = self._add_field(pb_field, str(index))
                         self._set_attributes(pb_inner, entry, attribute_specs.nested_attributes)
                 else:
-                    self._set_attributes(
-                        pb_field,
-                        attribute.nested,
-                        attribute_specs.nested_attributes,
-                    )
+                    self._set_attributes(pb_field, attribute.nested, attribute_specs.nested_attributes)
             else:
                 self._set_attribute(pb_field, attribute.value, attribute_type)
         for name in values_not_set:
             attribute_specs = specs[name]
             if attribute_specs.is_mandatory:
-                pb_field = ProtoWriter._add_field(pb_parent, name)
+                pb_field = self._add_field(pb_parent, name)
                 self._set_attribute(pb_field, attribute_specs.default_value, attribute_specs.attr_type)
-                log.info(ProtoWriter._USING_DEFAULT.format(name))
+                log().info(self._USING_DEFAULT.format(name))
 
     @staticmethod
-    def _add_field(pb_parent, name: str) -> Any:
+    def _add_field(pb_parent: Union[InputData.AgentDao, NestedField], name: str) -> NestedField:
         """Returns new field with given `name` that is added to given `pb_parent`"""
         pb_field = pb_parent.field.add()
         pb_field.fieldName = name
         return pb_field
 
-    def _set_attribute(self, pb_field, value, attribute_type: AttributeType) -> None:
+    def _set_attribute(self, pb_field: NestedField, value: Any, attribute_type: AttributeType) -> None:
         """Sets given `value` to given protobuf `pb_field` depending on specified `attribute_type`"""
         if attribute_type is AttributeType.INTEGER:
             pb_field.intValue.extend(ensure_is_list(value))
@@ -146,63 +150,21 @@ class ProtoWriter:
         elif attribute_type in (AttributeType.ENUM, AttributeType.STRING):
             pb_field.stringValue.extend(ensure_is_list(value))
         elif attribute_type is AttributeType.TIME_SERIES:
-            self._set_time_series_from_value(pb_field, value)
+            pb_field.seriesId = self._time_series_manager.get_series_id_by_identifier(value)
         else:
-            log_error_and_raise(ProtoWriterException(ProtoWriter._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
-
-    def _set_time_series_from_value(self, pb_field, value):
-        """Hands given `value` to TimeSeriesManager to assign a unique id which is then set to `pb_field`.seriesId"""
-        if not isinstance(value, (str, int, float)):
-            log_error_and_raise(ProtoWriterException(ProtoWriter._NOT_TIME_SERIES.format(str(value))))
-        elif isinstance(value, str):
-            value = Path(value).as_posix()
-        pb_field.seriesId = self.time_series_manager.save_get_time_series_id(value)
-
-    def _set_time_series(self, pb_input):
-        """Adds all time series from TimeSeriesManager to given `pb_input`"""
-        ids_of_series_by_name = self.time_series_manager.get_ids_of_series_by_name()
-        for identifier, unique_id in ids_of_series_by_name.items():
-            pb_series = pb_input.timeSeries.add()
-            pb_series.seriesId = unique_id
-            series_name, data_frame = self._get_series_as_dataframe(identifier)
-            pb_series.seriesName = series_name
-            try:
-                ProtoWriter._add_rows_to_series(pb_series, data_frame)
-            except TypeError:
-                log_error_and_raise(ProtoWriterException(ProtoWriter._CORRUPT_TIME_SERIES_VALUE.format(identifier)))
-            except ConversionException:
-                log_error_and_raise(ProtoWriterException(ProtoWriter._CORRUPT_TIME_SERIES_KEY.format(identifier)))
-
-    def _get_series_as_dataframe(self, identifier) -> (str, pd.DataFrame):
-        """Returns a DataFrame containing the series obtained from the given `identifier` and an associated name"""
-        if isinstance(identifier, str):
-            # expect the string to be a file path
-            series_path = self._path_resolver.resolve_series_file_path(identifier)
-            if series_path and os.path.exists(series_path):
-                return identifier, pd.read_csv(series_path, sep=";", header=None)
-            log_error_and_raise(ProtoWriterException(ProtoWriter._TIME_SERIES_FILE_NOT_FOUND.format(identifier)))
-        else:
-            name = "Constant value: {}".format(identifier)
-            return name, pd.DataFrame({"time": [START_IN_REAL_TIME], "value": [identifier]})
+            log_error_and_raise(ProtoWriterException(self._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
 
     @staticmethod
-    def _add_rows_to_series(series, data_frame):
-        for key, value in data_frame.itertuples(index=False):
-            row = series.row.add()
-            row.timeStep = FameTime.convert_string_if_is_datetime(key)
-            row.value = value
-
-    def _write_protobuf_to_disk(self, pb_data_storage) -> None:
-        """Writes given `protobuf_input_data` to disk"""
-        try:
-            with open(self.file_path, "wb") as file:
-                file.write(pb_data_storage.SerializeToString())
-        except OSError as e:
-            log_error_and_raise(ProtoWriterException(ProtoWriter._NO_FILE_SPECIFIED.format(self.file_path), e))
-        log.info("Saved protobuf file `{}` to disk".format(self.file_path))
+    def _add_contracts(pb_input: InputData, contracts: List[Contract]) -> None:
+        """Triggers setting of `contracts` to `pb_input`"""
+        log().info("Adding Contracts")
+        for contract in contracts:
+            pb_contract = ProtoWriter._set_contract(pb_input.contract.add(), contract)
+            ProtoWriter._set_contract_attributes(pb_contract, contract.attributes)
+            pb_contract.metadata = repr(contract.meta_data)
 
     @staticmethod
-    def _set_contract(pb_contract, contract: Contract):
+    def _set_contract(pb_contract: ProtoContract, contract: Contract) -> ProtoContract:
         """Saves given `contract` details to protobuf container `pb_contract`. Returns given `pb_contract`"""
         pb_contract.senderId = contract.sender_id
         pb_contract.receiverId = contract.receiver_id
@@ -214,10 +176,12 @@ class ProtoWriter:
         return pb_contract
 
     @staticmethod
-    def _set_contract_attributes(pb_parent, attributes: Dict[str, Attribute]) -> None:
+    def _set_contract_attributes(
+        pb_parent: Union[ProtoContract, NestedField], attributes: Dict[str, Attribute]
+    ) -> None:
         """Assign (nested) Attributes to given protobuf container `pb_parent`"""
         for name, attribute in attributes.items():
-            log.debug("Assigning contract attribute `{}`.".format(name))
+            log().debug("Assigning contract attribute `{}`.".format(name))
             pb_field = ProtoWriter._add_field(pb_parent, name)
 
             if attribute.has_value:
@@ -232,3 +196,46 @@ class ProtoWriter:
                     log_error_and_raise(ProtoWriterException(ProtoWriter._CONTRACT_UNSUPPORTED.format(str(attribute))))
             elif attribute.has_nested:
                 ProtoWriter._set_contract_attributes(pb_field, attribute.nested)
+
+    def _set_time_series(self, pb_input: InputData) -> None:
+        """Adds all time series from TimeSeriesManager to given `pb_input`"""
+        log().info("Adding TimeSeries")
+        for unique_id, identifier, data in self._time_series_manager.get_all_series():
+            pb_series = pb_input.timeSeries.add()
+            pb_series.seriesId = unique_id
+            pb_series.seriesName = identifier
+            ProtoWriter._add_rows_to_series(pb_series, data)
+
+    @staticmethod
+    def _add_rows_to_series(series: InputData.TimeSeriesDao, data_frame) -> None:
+        for key, value in data_frame.itertuples(index=False):
+            row = series.row.add()
+            row.timeStep = int(key)
+            row.value = value
+
+    @staticmethod
+    def _set_schema(pb_input: InputData, schema: Schema) -> None:
+        """Sets the given `schema` `pb_input`"""
+        log().info("Adding Schema")
+        pb_input.schema = schema.to_string()
+
+    @staticmethod
+    def _set_java_package_names(pb_model: ModelData, java_packages: JavaPackages) -> None:
+        """Adds given JavaPackages names to given ModelData section"""
+        pb_packages = pb_model.packages
+        pb_packages.agent.extend(java_packages.agents)
+        pb_packages.dataItem.extend(java_packages.data_items)
+        pb_packages.portable.extend(java_packages.portables)
+
+    def _write_protobuf_to_disk(self, pb_data_storage: DataStorage) -> None:
+        """Writes given `protobuf_input_data` to disk"""
+        log().info(self._INFO_WRITING.format(self.file_path))
+        try:
+            with open(self.file_path, "wb") as file:
+                serialised_data_storage = pb_data_storage.SerializeToString()
+                file.write(self._FAME_PROTOBUF_STREAM_HEADER.encode(Reader.HEADER_ENCODING))
+                file.write(len(serialised_data_storage).to_bytes(Reader.BYTES_DEFINING_MESSAGE_LENGTH, byteorder="big"))
+                file.write(serialised_data_storage)
+        except OSError as e:
+            log_error_and_raise(ProtoWriterException(ProtoWriter._NO_FILE_SPECIFIED.format(self.file_path), e))
+        log().info(self._INFO_WRITING_COMPLETED.format(self.file_path))

fameio-2.1.0.dist-info/LICENSES/Apache-2.0.txt

@@ -0,0 +1,178 @@
+Copyright 2020 German Aerospace Center
+
+                                 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