openmetadata-ingestion 1.5.11.0__py3-none-any.whl → 1.6.0.0rc1__py3-none-any.whl

metadata/utils/ssl_manager.py

@@ -45,6 +45,9 @@ from metadata.generated.schema.entity.services.connections.database.salesforceCo
 from metadata.generated.schema.entity.services.connections.messaging.kafkaConnection import (
     KafkaConnection,
 )
+from metadata.generated.schema.entity.services.connections.pipeline.matillionConnection import (
+    MatillionConnection,
+)
 from metadata.generated.schema.security.ssl import verifySSLConfig
 from metadata.ingestion.connections.builders import init_empty_connection_arguments
 from metadata.ingestion.models.custom_pydantic import CustomSecretStr
@@ -106,6 +109,21 @@ class SSLManager:
         connection.connectionArguments.root["ssl"] = ssl_args
         return connection
 
+    @setup_ssl.register(MatillionConnection)
+    def _(self, connection):
+        matillion_connection = cast(MatillionConnection, connection)
+        if (
+            matillion_connection.connection
+            and matillion_connection.connection.sslConfig
+        ):
+            if matillion_connection.connection.sslConfig.root.caCertificate:
+                setattr(
+                    matillion_connection.connection.sslConfig.root,
+                    "caCertificate",
+                    self.ca_file_path,
+                )
+        return connection
+
     @setup_ssl.register(PostgresConnection)
     @setup_ssl.register(RedshiftConnection)
     @setup_ssl.register(GreenplumConnection)
@@ -174,6 +192,21 @@ def check_ssl_and_init(_) -> None:
     return None
 
 
+@check_ssl_and_init.register(MatillionConnection)
+def _(connection) -> Union[SSLManager, None]:
+    service_connection = cast(MatillionConnection, connection)
+    if service_connection.connection:
+        ssl: Optional[
+            verifySSLConfig.SslConfig
+        ] = service_connection.connection.sslConfig
+        if ssl and ssl.root.caCertificate:
+            ssl_dict: dict[str, Union[CustomSecretStr, None]] = {
+                "ca": ssl.root.caCertificate
+            }
+            return SSLManager(**ssl_dict)
+    return None
+
+
 @check_ssl_and_init.register(cls=SalesforceConnection)
 def _(connection) -> Union[SSLManager, None]:
     service_connection = cast(SalesforceConnection, connection)

metadata/utils/time_utils.py

@@ -17,28 +17,55 @@ from datetime import datetime, time, timedelta, timezone
 from math import floor
 from typing import Union
 
+from metadata.generated.schema.type.basic import Timestamp
+from metadata.utils.deprecation import deprecated
 from metadata.utils.helpers import datetime_to_ts
+from metadata.utils.logger import utils_logger
 
+logger = utils_logger()
 
-def datetime_to_timestamp(datetime_value, milliseconds=False) -> int:
-    """Convert a datetime object to timestamp integer
+
+def datetime_to_timestamp(datetime_value: datetime, milliseconds=False) -> int:
+    """Convert a datetime object to timestamp integer. If datetime is timezone aware, it will be converted to UTC.
+    If it is naive it will be assumed to be in UTC.
+
+    # TODO: not sure the milliseconds flag is useful. Maybe this should return a 'Timestamp' object instead.
 
     Args:
         datetime_value (_type_): datetime object
         milliseconds (bool, optional): make it a milliseconds timestamp. Defaults to False.
 
     Returns:
-        int:
+        int : timestamp in seconds or milliseconds
     """
     if not getattr(datetime_value, "timestamp", None):
-        raise TypeError(f"Object of type {datetime_value} has not method `timestamp()`")
-
+        raise TypeError(
+            f"Object of type {type(datetime_value).__name__} has not method `timestamp()`"
+        )
+
+    datetime_value = (
+        datetime_value.replace(tzinfo=timezone.utc)
+        if datetime_value.tzinfo is None
+        else datetime_value.astimezone(timezone.utc)
+    )
     tmsap = datetime_value.timestamp()
     if milliseconds:
         return int(tmsap * 1000)
     return int(tmsap)
 
 
+def timestamp_to_datetime(ts: Timestamp) -> datetime:
+    """Convert a timestamp to datetime object in UTC.
+
+    Args:
+        ts (Timestamp): timestamp
+
+    Returns:
+        datetime: datetime object
+    """
+    return datetime.fromtimestamp(ts.root / 1000, tz=timezone.utc)
+
+
 def get_beginning_of_day_timestamp_mill(
     days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0
 ) -> int:
@@ -115,6 +142,7 @@ def convert_timestamp(timestamp: str) -> Union[int, float]:
     return float(timestamp) / 1000
 
 
+@deprecated("Use `datetime_to_timestamp` instead", "1.7.0")
 def convert_timestamp_to_milliseconds(timestamp: Union[int, float]) -> int:
     """convert timestamp to milliseconds
     Args:

metadata/workflow/application.py

@@ -14,10 +14,6 @@ Generic Workflow entrypoint to execute Applications
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
-from metadata.config.common import WorkflowExecutionError
-from metadata.generated.schema.entity.services.connections.metadata.openMetadataConnection import (
-    OpenMetadataConnection,
-)
 from metadata.generated.schema.entity.services.ingestionPipelines.status import (
     StackTraceError,
 )
@@ -25,13 +21,11 @@ from metadata.generated.schema.entity.services.serviceType import ServiceType
 from metadata.generated.schema.metadataIngestion.application import (
     OpenMetadataApplicationConfig,
 )
-from metadata.generated.schema.metadataIngestion.workflow import LogLevels
-from metadata.ingestion.api.step import Step, Summary
+from metadata.ingestion.api.step import Step
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils.importer import import_from_module
 from metadata.utils.logger import ingestion_logger
 from metadata.workflow.base import BaseWorkflow
-from metadata.workflow.workflow_status_mixin import SUCCESS_THRESHOLD_VALUE
 
 logger = ingestion_logger()
 
@@ -84,29 +78,24 @@ class ApplicationWorkflow(BaseWorkflow, ABC):
     config: OpenMetadataApplicationConfig
     runner: Optional[AppRunner]
 
-    def __init__(self, config_dict: dict):
+    def __init__(self, config: OpenMetadataApplicationConfig):
         self.runner = None  # Will be passed in post-init
-        # TODO: Create a parse_gracefully method
-        self.config = OpenMetadataApplicationConfig.model_validate(config_dict)
+        self.config = config
 
         # Applications are associated to the OpenMetadata Service
         self.service_type: ServiceType = ServiceType.Metadata
 
-        metadata_config: OpenMetadataConnection = (
-            self.config.workflowConfig.openMetadataServerConfig
-        )
-        log_level: LogLevels = self.config.workflowConfig.loggerLevel
-
         super().__init__(
             config=self.config,
-            log_level=log_level,
-            metadata_config=metadata_config,
+            workflow_config=config.workflowConfig,
             service_type=self.service_type,
         )
 
     @classmethod
     def create(cls, config_dict: dict):
-        return cls(config_dict)
+        # TODO: Create a parse_gracefully method
+        config = OpenMetadataApplicationConfig.model_validate(config_dict)
+        return cls(config)
 
     def post_init(self) -> None:
         """
@@ -134,26 +123,8 @@ class ApplicationWorkflow(BaseWorkflow, ABC):
         """Workflow-specific logic to execute safely"""
         self.runner.run()
 
-    def calculate_success(self) -> float:
-        return self.runner.get_status().calculate_success()
-
     def get_failures(self) -> List[StackTraceError]:
         return self.workflow_steps()[0].get_status().failures
 
     def workflow_steps(self) -> List[Step]:
         return [self.runner]
-
-    def raise_from_status_internal(self, raise_warnings=False):
-        """Check failed status in the runner"""
-        if (
-            self.runner.get_status().failures
-            and self.calculate_success() < SUCCESS_THRESHOLD_VALUE
-        ):
-            raise WorkflowExecutionError(
-                f"{self.runner.name} reported errors: {Summary.from_step(self.runner)}"
-            )
-
-        if raise_warnings and self.runner.get_status().warnings:
-            raise WorkflowExecutionError(
-                f"{self.runner.name} reported warning: {Summary.from_step(self.runner)}"
-            )

metadata/workflow/base.py

@@ -16,8 +16,10 @@ import traceback
 import uuid
 from abc import ABC, abstractmethod
 from datetime import datetime
+from statistics import mean
 from typing import Any, Dict, List, Optional, TypeVar, Union
 
+from metadata.config.common import WorkflowExecutionError
 from metadata.generated.schema.api.services.ingestionPipelines.createIngestionPipeline import (
     CreateIngestionPipelineRequest,
 )
@@ -32,10 +34,13 @@ from metadata.generated.schema.entity.services.ingestionPipelines.ingestionPipel
 from metadata.generated.schema.entity.services.ingestionPipelines.status import (
     StackTraceError,
 )
-from metadata.generated.schema.metadataIngestion.workflow import LogLevels
+from metadata.generated.schema.metadataIngestion.workflow import (
+    LogLevels,
+    WorkflowConfig,
+)
 from metadata.generated.schema.tests.testSuite import ServiceType
 from metadata.generated.schema.type.entityReference import EntityReference
-from metadata.ingestion.api.step import Step
+from metadata.ingestion.api.step import Step, Summary
 from metadata.ingestion.ometa.client_utils import create_ometa_client
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.timer.repeated_timer import RepeatedTimer
@@ -49,10 +54,7 @@ from metadata.utils.execution_time_tracker import ExecutionTimeTracker
 from metadata.utils.helpers import datetime_to_ts
 from metadata.utils.logger import ingestion_logger, set_loggers_level
 from metadata.workflow.workflow_output_handler import WorkflowOutputHandler
-from metadata.workflow.workflow_status_mixin import (
-    SUCCESS_THRESHOLD_VALUE,
-    WorkflowStatusMixin,
-)
+from metadata.workflow.workflow_status_mixin import WorkflowStatusMixin
 
 logger = ingestion_logger()
 
@@ -82,8 +84,7 @@ class BaseWorkflow(ABC, WorkflowStatusMixin):
     def __init__(
         self,
         config: Union[Any, Dict],
-        log_level: LogLevels,
-        metadata_config: OpenMetadataConnection,
+        workflow_config: WorkflowConfig,
         service_type: ServiceType,
         output_handler: WorkflowOutputHandler = WorkflowOutputHandler(),
     ):
@@ -92,19 +93,22 @@ class BaseWorkflow(ABC, WorkflowStatusMixin):
         """
         self.output_handler = output_handler
         self.config = config
+        self.workflow_config = workflow_config
         self.service_type = service_type
         self._timer: Optional[RepeatedTimer] = None
         self._ingestion_pipeline: Optional[IngestionPipeline] = None
         self._start_ts = datetime_to_ts(datetime.now())
+
         self._execution_time_tracker = ExecutionTimeTracker(
-            log_level == LogLevels.DEBUG
+            self.workflow_config.loggerLevel == LogLevels.DEBUG
         )
 
-        set_loggers_level(log_level.value)
+        set_loggers_level(self.workflow_config.loggerLevel.value)
 
         # We create the ometa client at the workflow level and pass it to the steps
-        self.metadata_config = metadata_config
-        self.metadata = create_ometa_client(metadata_config)
+        self.metadata = create_ometa_client(
+            self.workflow_config.openMetadataServerConfig
+        )
         self.set_ingestion_pipeline_status(state=PipelineState.running)
 
         self.post_init()
@@ -157,9 +161,22 @@ class BaseWorkflow(ABC, WorkflowStatusMixin):
     def execute_internal(self) -> None:
         """Workflow-specific logic to execute safely"""
 
-    @abstractmethod
-    def calculate_success(self) -> float:
-        """Get the success % of the internal execution"""
+    def calculate_success(self) -> Optional[float]:
+        """
+        Get the success % of the internal execution.
+        Since we'll use this to get a single success % from multiple steps, we'll take
+        the minimum success % from all the steps. This way, we can have a proper
+        workflow status.
+        E.g., if we have no errors on the source but a bunch of them on the sink,
+        we still want the flow to be marked as a failure or partial success.
+        """
+        if not self.workflow_steps():
+            logger.warning("No steps to calculate success")
+            return None
+
+        return mean(
+            [step.get_status().calculate_success() for step in self.workflow_steps()]
+        )
 
     @abstractmethod
     def get_failures(self) -> List[StackTraceError]:
@@ -169,9 +186,22 @@ class BaseWorkflow(ABC, WorkflowStatusMixin):
     def workflow_steps(self) -> List[Step]:
         """Steps to report status from"""
 
-    @abstractmethod
     def raise_from_status_internal(self, raise_warnings=False) -> None:
         """Based on the internal workflow status, raise a WorkflowExecutionError"""
+        for step in self.workflow_steps():
+            if (
+                step.get_status().failures
+                and step.get_status().calculate_success()
+                < self.workflow_config.successThreshold
+            ):
+                raise WorkflowExecutionError(
+                    f"{step.name} reported errors: {Summary.from_step(step)}"
+                )
+
+            if raise_warnings and step.status.warnings:
+                raise WorkflowExecutionError(
+                    f"{step.name} reported warning: {Summary.from_step(step)}"
+                )
 
     def execute(self) -> None:
         """
@@ -186,7 +216,7 @@ class BaseWorkflow(ABC, WorkflowStatusMixin):
         try:
             self.execute_internal()
 
-            if SUCCESS_THRESHOLD_VALUE <= self.calculate_success() < 100:
+            if self.workflow_config.successThreshold <= self.calculate_success() < 100:
                 pipeline_state = PipelineState.partialSuccess
 
         # Any unhandled exception breaking the workflow should update the status

metadata/workflow/ingestion.py

@@ -24,9 +24,6 @@ from abc import ABC, abstractmethod
 from typing import List, Tuple, Type, cast
 
 from metadata.config.common import WorkflowExecutionError
-from metadata.generated.schema.entity.services.connections.metadata.openMetadataConnection import (
-    OpenMetadataConnection,
-)
 from metadata.generated.schema.entity.services.connections.serviceConnection import (
     ServiceConnection,
 )
@@ -38,7 +35,7 @@ from metadata.generated.schema.metadataIngestion.workflow import (
     OpenMetadataWorkflowConfig,
 )
 from metadata.ingestion.api.parser import parse_workflow_config_gracefully
-from metadata.ingestion.api.step import Step, Summary
+from metadata.ingestion.api.step import Step
 from metadata.ingestion.api.steps import BulkSink, Processor, Sink, Source, Stage
 from metadata.ingestion.models.custom_types import ServiceWithConnectionType
 from metadata.profiler.api.models import ProfilerProcessorConfig
@@ -51,18 +48,19 @@ from metadata.utils.importer import (
     DynamicImportException,
     MissingPluginException,
     import_from_module,
-    import_source_class,
 )
 from metadata.utils.logger import ingestion_logger
+from metadata.utils.service_spec.service_spec import import_source_class
 from metadata.workflow.base import BaseWorkflow, InvalidWorkflowJSONException
-from metadata.workflow.workflow_status_mixin import SUCCESS_THRESHOLD_VALUE
 
 logger = ingestion_logger()
 
 
 class IngestionWorkflow(BaseWorkflow, ABC):
     """
-    Base Ingestion Workflow implementation
+    Base Ingestion Workflow implementation. This is used for all
+    workflows minus the application one, which directly inherits the
+    BaseWorkflow.
     """
 
     config: OpenMetadataWorkflowConfig
@@ -79,14 +77,9 @@ class IngestionWorkflow(BaseWorkflow, ABC):
             self.config.source.type
         )
 
-        metadata_config: OpenMetadataConnection = (
-            self.config.workflowConfig.openMetadataServerConfig
-        )
-
         super().__init__(
             config=config,
-            log_level=config.workflowConfig.loggerLevel,
-            metadata_config=metadata_config,
+            workflow_config=config.workflowConfig,
             service_type=self.service_type,
         )
 
@@ -137,37 +130,12 @@ class IngestionWorkflow(BaseWorkflow, ABC):
         if bulk_sink:
             bulk_sink.run()
 
-    def calculate_success(self) -> float:
-        return self.source.get_status().calculate_success()
-
     def get_failures(self) -> List[StackTraceError]:
         return self.source.get_status().failures
 
     def workflow_steps(self) -> List[Step]:
         return [self.source] + list(self.steps)
 
-    def raise_from_status_internal(self, raise_warnings=False):
-        """
-        Check the status of all steps
-        """
-        if (
-            self.source.get_status().failures
-            and self.calculate_success() < SUCCESS_THRESHOLD_VALUE
-        ):
-            raise WorkflowExecutionError(
-                f"{self.source.name} reported errors: {Summary.from_step(self.source)}"
-            )
-
-        for step in self.steps:
-            if step.status.failures:
-                raise WorkflowExecutionError(
-                    f"{step.name} reported errors: {Summary.from_step(step)}"
-                )
-            if raise_warnings and step.status.warnings:
-                raise WorkflowExecutionError(
-                    f"{step.name} reported warnings: {Summary.from_step(step)}"
-                )
-
     def _retrieve_service_connection_if_needed(self, service_type: ServiceType) -> None:
         """
         We override the current `serviceConnection` source config object if source workflow service already exists

metadata/workflow/workflow_output_handler.py

@@ -14,6 +14,7 @@ Module handles the output messages from different workflows
 """
 
 import time
+from statistics import mean
 from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
@@ -114,16 +115,15 @@ class WorkflowOutputHandler:
 
         self._print_summary(steps)
 
-    def _print_summary(self, steps: List[Step]):
+    def _print_summary(self, steps: List[Step]) -> None:
         failures: List[Failure] = []
-        total_records: int = 0
-        total_errors: int = 0
+        if not steps:
+            log_ansi_encoded_string(message="No steps to process.")
+            return
 
         for step in steps:
             step_summary = Summary.from_step(step)
 
-            total_records += step_summary.records or 0
-            total_errors += step_summary.errors or 0
             failures.append(
                 Failure(name=step.name, failures=step.get_status().failures)
             )
@@ -141,15 +141,18 @@ class WorkflowOutputHandler:
                 log_ansi_encoded_string(message=f"Filtered: {step_summary.filtered}")
 
             log_ansi_encoded_string(message=f"Errors: {step_summary.errors}")
+            log_ansi_encoded_string(
+                message=f"Success %: {step.get_status().calculate_success()}"
+            )
 
         self._print_failures_if_apply(failures)
 
-        total_success = max(total_records, 1)
+        # If nothing is processed, we'll have a success of 100%
+        success_pct = mean([step.get_status().calculate_success() for step in steps])
         log_ansi_encoded_string(
             color=ANSI.BRIGHT_CYAN,
             bold=True,
-            message="Success %: "
-            + f"{round(total_success * 100 / (total_success + total_errors), 2)}",
+            message="Workflow Success %: " + f"{round(success_pct, 2)}",
         )
 
     def _print_debug_summary(self, steps: List[Step]):

metadata/workflow/workflow_status_mixin.py

@@ -37,8 +37,6 @@ from metadata.utils.logger import ometa_logger
 
 logger = ometa_logger()
 
-SUCCESS_THRESHOLD_VALUE = 90
-
 
 class WorkflowResultStatus(Enum):
     SUCCESS = 0

openmetadata_ingestion-1.6.0.0rc1.dist-info/LICENSE

@@ -0,0 +1,114 @@
+                       Collate Community License Agreement
+                                Version 1.0
+
+This Collate Community License Agreement Version 1.0 (the “Agreement”) sets
+forth the terms on which Collate, Inc. (“Collate”) makes available certain
+software made available by Collate under this Agreement (the “Software”).  BY
+INSTALLING, DOWNLOADING, ACCESSING, USING OR DISTRIBUTING ANY OF THE SOFTWARE,
+YOU AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE TO
+SUCH TERMS AND CONDITIONS, YOU MUST NOT USE THE SOFTWARE.  IF YOU ARE RECEIVING
+THE SOFTWARE ON BEHALF OF A LEGAL ENTITY, YOU REPRESENT AND WARRANT THAT YOU
+HAVE THE ACTUAL AUTHORITY TO AGREE TO THE TERMS AND CONDITIONS OF THIS
+AGREEMENT ON BEHALF OF SUCH ENTITY.  “Licensee” means you, an individual, or
+the entity on whose behalf you are receiving the Software.
+
+   1. LICENSE GRANT AND CONDITIONS.
+
+      1.1 License.  Subject to the terms and conditions of this Agreement,
+      Collate hereby grants to Licensee a non-exclusive, royalty-free,
+      worldwide, non-transferable, non-sublicenseable license during the term
+      of this Agreement to: (a) use the Software; (b) prepare modifications and
+      derivative works of the Software; (c) distribute the Software (including
+      without limitation in source code or object code form); and (d) reproduce
+      copies of the Software (the “License”).  Licensee is not granted the
+      right to, and Licensee shall not, exercise the License for an Excluded
+      Purpose.  For purposes of this Agreement, “Excluded Purpose” means making
+      available any software-as-a-service, platform-as-a-service,
+      infrastructure-as-a-service or other similar online service that competes
+      with Collate products or services that provide the Software.
+
+      1.2 Conditions.  In consideration of the License, Licensee’s distribution
+      of the Software is subject to the following conditions:
+
+         (a) Licensee must cause any Software modified by Licensee to carry
+         prominent notices stating that Licensee modified the Software.
+
+         (b) On each Software copy, Licensee shall reproduce and not remove or
+         alter all Collate or third party copyright or other proprietary
+         notices contained in the Software, and Licensee must provide the
+         notice below with each copy.
+
+            “This software is made available by Collate, Inc., under the
+            terms of the Collate Community License Agreement, Version 1.0
+            located at http://www.getcollate.io/collate-community-license.  BY
+            INSTALLING, DOWNLOADING, ACCESSING, USING OR DISTRIBUTING ANY OF
+            THE SOFTWARE, YOU AGREE TO THE TERMS OF SUCH LICENSE AGREEMENT.”
+
+      1.3 Licensee Modifications.  Licensee may add its own copyright notices
+      to modifications made by Licensee and may provide additional or different
+      license terms and conditions for use, reproduction, or distribution of
+      Licensee’s modifications.  While redistributing the Software or
+      modifications thereof, Licensee may choose to offer, for a fee or free of
+      charge, support, warranty, indemnity, or other obligations. Licensee, and
+      not Collate, will be responsible for any such obligations.
+
+      1.4 No Sublicensing.  The License does not include the right to
+      sublicense the Software, however, each recipient to which Licensee
+      provides the Software may exercise the Licenses so long as such recipient
+      agrees to the terms and conditions of this Agreement.
+
+   2. TERM AND TERMINATION.  This Agreement will continue unless and until
+   earlier terminated as set forth herein.  If Licensee breaches any of its
+   conditions or obligations under this Agreement, this Agreement will
+   terminate automatically and the License will terminate automatically and
+   permanently.
+
+   3. INTELLECTUAL PROPERTY.  As between the parties, Collate will retain all
+   right, title, and interest in the Software, and all intellectual property
+   rights therein.  Collate hereby reserves all rights not expressly granted
+   to Licensee in this Agreement.  Collate hereby reserves all rights in its
+   trademarks and service marks, and no licenses therein are granted in this
+   Agreement.
+
+   4. DISCLAIMER.  COLLATE HEREBY DISCLAIMS ANY AND ALL WARRANTIES AND
+   CONDITIONS, EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, AND SPECIFICALLY
+   DISCLAIMS ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+   PURPOSE, WITH RESPECT TO THE SOFTWARE.
+
+   5. LIMITATION OF LIABILITY.  COLLATE WILL NOT BE LIABLE FOR ANY DAMAGES OF
+   ANY KIND, INCLUDING BUT NOT LIMITED TO, LOST PROFITS OR ANY CONSEQUENTIAL,
+   SPECIAL, INCIDENTAL, INDIRECT, OR DIRECT DAMAGES, HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, ARISING OUT OF THIS AGREEMENT.  THE FOREGOING SHALL
+   APPLY TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+
+   6.GENERAL.
+
+      6.1 Governing Law. This Agreement will be governed by and interpreted in
+      accordance with the laws of the state of California, without reference to
+      its conflict of laws principles.  If Licensee is located within the
+      United States, all disputes arising out of this Agreement are subject to
+      the exclusive jurisdiction of courts located in Santa Clara County,
+      California. USA.  If Licensee is located outside of the United States,
+      any dispute, controversy or claim arising out of or relating to this
+      Agreement will be referred to and finally determined by arbitration in
+      accordance with the JAMS International Arbitration Rules.  The tribunal
+      will consist of one arbitrator.  The place of arbitration will be Palo
+      Alto, California. The language to be used in the arbitral proceedings
+      will be English.  Judgment upon the award rendered by the arbitrator may
+      be entered in any court having jurisdiction thereof.
+
+      6.2 Assignment.  Licensee is not authorized to assign its rights under
+      this Agreement to any third party. Collate may freely assign its rights
+      under this Agreement to any third party.
+
+      6.3 Other.  This Agreement is the entire agreement between the parties
+      regarding the subject matter hereof.  No amendment or modification of
+      this Agreement will be valid or binding upon the parties unless made in
+      writing and signed by the duly authorized representatives of both
+      parties.  In the event that any provision, including without limitation
+      any condition, of this Agreement is held to be unenforceable, this
+      Agreement and all licenses and rights granted hereunder will immediately
+      terminate.  Waiver by Collate of a breach of any provision of this
+      Agreement or the failure by Collate to exercise any right hereunder
+      will not be construed as a waiver of any subsequent breach of that right
+      or as a waiver of any other right.