deltafi 1.1.16__py3-none-any.whl → 2.0rc1705013410531__py3-none-any.whl

deltafi/action.py

@@ -22,18 +22,15 @@ from typing import Any, List
 from deltafi.actiontype import ActionType
 from deltafi.genericmodel import GenericModel
 from deltafi.domain import Context, DeltaFileMessage
-from deltafi.input import DomainInput, EgressInput, EnrichInput, FormatInput, LoadInput, TransformInput, ValidateInput
+from deltafi.input import EgressInput, TransformInput
 from deltafi.result import *
 from pydantic import BaseModel
 
 
 class Action(ABC):
-    def __init__(self, action_type: ActionType, description: str, requires_domains: List[str],
-                 requires_enrichments: List[str], valid_result_types: tuple):
+    def __init__(self, action_type: ActionType, description: str, valid_result_types: tuple):
         self.action_type = action_type
         self.description = description
-        self.requires_domains = requires_domains
-        self.requires_enrichments = requires_enrichments
         self.valid_result_types = valid_result_types
         self.action_execution = None
 
@@ -81,25 +78,9 @@ class Action(ABC):
                              f"but a {result.__class__.__name__} was returned")
 
 
-class DomainAction(Action, ABC):
-    def __init__(self, description: str, requires_domains: List[str]):
-        super().__init__(ActionType.DOMAIN, description, requires_domains, [], (DomainResult, ErrorResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return DomainInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata,
-                           domains={domain.name: domain for domain in delta_file_message.domains})
-
-    @abstractmethod
-    def domain(self, context: Context, params: BaseModel, domain_input: DomainInput):
-        pass
-
-    def execute(self, context: Context, domain_input: DomainInput, params: BaseModel):
-        return self.domain(context, params, domain_input)
-
-
 class EgressAction(Action, ABC):
     def __init__(self, description: str):
-        super().__init__(ActionType.EGRESS, description, [], [], (EgressResult, ErrorResult, FilterResult))
+        super().__init__(ActionType.EGRESS, description, (EgressResult, ErrorResult, FilterResult))
 
     def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
         return EgressInput(content=delta_file_message.content_list[0], metadata=delta_file_message.metadata)
@@ -112,81 +93,9 @@ class EgressAction(Action, ABC):
         return self.egress(context, params, egress_input)
 
 
-class EnrichAction(Action, ABC):
-    def __init__(self, description: str, requires_domains: List[str], requires_enrichments: List[str]):
-        super().__init__(ActionType.ENRICH, description, requires_domains, requires_enrichments,
-                         (EnrichResult, ErrorResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return EnrichInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata,
-                           domains={domain.name: domain for domain in delta_file_message.domains},
-                           enrichments={domain.name: domain for domain in delta_file_message.enrichments})
-
-    @abstractmethod
-    def enrich(self, context: Context, params: BaseModel, enrich_input: EnrichInput):
-        pass
-
-    def execute(self, context: Context, enrich_input: EnrichInput, params: BaseModel):
-        return self.enrich(context, params, enrich_input)
-
-
-class FormatAction(Action, ABC):
-    def __init__(self, description: str, requires_domains: List[str], requires_enrichments: List[str]):
-        super().__init__(ActionType.FORMAT, description, requires_domains, requires_enrichments,
-                         (FormatResult, FormatManyResult, ErrorResult, FilterResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return FormatInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata,
-                           domains={domain.name: domain for domain in delta_file_message.domains},
-                           enrichments={domain.name: domain for domain in delta_file_message.enrichments})
-
-    def collect(self, format_inputs: List[FormatInput]):
-        all_content = []
-        all_metadata = {}
-        all_domains = {}
-        all_enrichments = {}
-        for format_input in format_inputs:
-            all_content += format_input.content
-            all_metadata.update(format_input.metadata)
-            all_domains.update(format_input.domains)
-            all_enrichments.update(format_input.enrichments)
-        return FormatInput(content=all_content, metadata=all_metadata, domains=all_domains, enrichments=all_enrichments)
-
-    @abstractmethod
-    def format(self, context: Context, params: BaseModel, format_input: FormatInput):
-        pass
-
-    def execute(self, context: Context, format_input: FormatInput, params: BaseModel):
-        return self.format(context, params, format_input)
-
-
-class LoadAction(Action, ABC):
-    def __init__(self, description: str):
-        super().__init__(ActionType.LOAD, description, [], [],
-                         (LoadResult, LoadManyResult, ErrorResult, FilterResult, ReinjectResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return LoadInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata)
-
-    def collect(self, load_inputs: List[LoadInput]):
-        all_content = []
-        all_metadata = {}
-        for load_input in load_inputs:
-            all_content += load_input.content
-            all_metadata.update(load_input.metadata)
-        return LoadInput(content=all_content, metadata=all_metadata)
-
-    @abstractmethod
-    def load(self, context: Context, params: BaseModel, load_input: LoadInput):
-        pass
-
-    def execute(self, context: Context, load_input: LoadInput, params: BaseModel):
-        return self.load(context, params, load_input)
-
-
 class TimedIngressAction(Action, ABC):
     def __init__(self, description: str):
-        super().__init__(ActionType.TIMED_INGRESS, description, [], [], (IngressResult, ErrorResult))
+        super().__init__(ActionType.TIMED_INGRESS, description, (IngressResult, ErrorResult))
 
     def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
         return None
@@ -201,7 +110,7 @@ class TimedIngressAction(Action, ABC):
 
 class TransformAction(Action, ABC):
     def __init__(self, description: str):
-        super().__init__(ActionType.TRANSFORM, description, [], [], (TransformResult, ErrorResult, FilterResult, ReinjectResult))
+        super().__init__(ActionType.TRANSFORM, description, (TransformResult, ErrorResult, FilterResult))
 
     def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
         return TransformInput(content=delta_file_message.content_list, metadata=delta_file_message.metadata)
@@ -220,18 +129,3 @@ class TransformAction(Action, ABC):
 
     def execute(self, context: Context, transform_input: TransformInput, params: BaseModel):
         return self.transform(context, params, transform_input)
-
-
-class ValidateAction(Action, ABC):
-    def __init__(self, description: str):
-        super().__init__(ActionType.VALIDATE, description, [], [], (ValidateResult, ErrorResult, FilterResult))
-
-    def build_input(self, context: Context, delta_file_message: DeltaFileMessage):
-        return ValidateInput(content=delta_file_message.content_list[0], metadata=delta_file_message.metadata)
-
-    @abstractmethod
-    def validate(self, context: Context, params: BaseModel, validate_input: ValidateInput):
-        pass
-
-    def execute(self, context: Context, validate_input: ValidateInput, params: BaseModel):
-        return self.validate(context, params, validate_input)

deltafi/actiontype.py

@@ -22,11 +22,5 @@ from enum import Enum
 class ActionType(Enum):
     TIMED_INGRESS = "TIMED_INGRESS"
     TRANSFORM = "TRANSFORM"
-    LOAD = "LOAD"
-    DOMAIN = "DOMAIN"
-    ENRICH = "ENRICH"
-    FORMAT = "FORMAT"
-    VALIDATE = "VALIDATE"
     EGRESS = "EGRESS"
-    DELETE = "DELETE"
     UNKNOWN = "UNKNOWN"

deltafi/input.py

@@ -17,172 +17,13 @@
 #
 
 from deltafi.domain import *
-from deltafi.exception import MissingMetadataException, ExpectedContentException, MissingDomainException, \
-    MissingEnrichmentException
-
-
-class DomainInput(NamedTuple):
-    content: List[Content]
-    metadata: Dict[str, str]
-    domains: Dict[str, Domain]
-
-    def has_content(self) -> bool:
-        return len(self.content) > 0
-
-    def content_at(self, index: int) -> Content:
-        if len(self.content) < index + 1:
-            raise ExpectedContentException(index, len(self.content))
-        return self.content[index]
-
-    def first_content(self):
-        return self.content_at(0)
-
-    def get_metadata(self, key: str):
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            raise MissingMetadataException(key)
-
-    def get_metadata_or_else(self, key: str, default: str) -> str:
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            return default
-
-    def has_domain(self, name: str) -> bool:
-        return name in self.domains
-
-    def domain(self, name: str) -> Domain:
-        if not self.has_domain(name):
-            raise MissingDomainException(name)
-        return self.domains[name]
-
+from deltafi.exception import MissingMetadataException, ExpectedContentException
 
 class EgressInput(NamedTuple):
     content: Content
     metadata: dict
 
 
-class EnrichInput(NamedTuple):
-    content: List[Content]
-    metadata: dict
-    domains: Dict[str, Domain]
-    enrichments: Dict[str, Domain]
-
-    def has_content(self) -> bool:
-        return len(self.content) > 0
-
-    def content_at(self, index: int) -> Content:
-        if len(self.content) < index + 1:
-            raise ExpectedContentException(index, len(self.content))
-        return self.content[index]
-
-    def first_content(self):
-        return self.content_at(0)
-
-    def get_metadata(self, key: str):
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            raise MissingMetadataException(key)
-
-    def get_metadata_or_else(self, key: str, default: str) -> str:
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            return default
-
-    def has_domain(self, name: str) -> bool:
-        return name in self.domains
-
-    def domain(self, name: str) -> Domain:
-        if not self.has_domain(name):
-            raise MissingDomainException(name)
-        return self.domains[name]
-
-    def has_enrichment(self, name: str) -> bool:
-        return name in self.enrichments
-
-    def enrichment(self, name: str) -> Domain:
-        if not self.has_enrichment(name):
-            raise MissingEnrichmentException(name)
-        return self.enrichments[name]
-
-
-class FormatInput(NamedTuple):
-    content: List[Content]
-    metadata: dict
-    domains: Dict[str, Domain]
-    enrichments: Dict[str, Domain]
-
-    def has_content(self) -> bool:
-        return len(self.content) > 0
-
-    def content_at(self, index: int) -> Content:
-        if len(self.content) < index + 1:
-            raise ExpectedContentException(index, len(self.content))
-        return self.content[index]
-
-    def first_content(self):
-        return self.content_at(0)
-
-    def get_metadata(self, key: str):
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            raise MissingMetadataException(key)
-
-    def get_metadata_or_else(self, key: str, default: str) -> str:
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            return default
-
-    def has_domain(self, name: str) -> bool:
-        return name in self.domains
-
-    def domain(self, name: str) -> Domain:
-        if not self.has_domain(name):
-            raise MissingDomainException(name)
-        return self.domains[name]
-
-    def has_enrichment(self, name: str) -> bool:
-        return name in self.enrichments
-
-    def enrichment(self, name: str) -> Domain:
-        if not self.has_enrichment(name):
-            raise MissingEnrichmentException(name)
-        return self.enrichments[name]
-
-
-class LoadInput(NamedTuple):
-    content: List[Content]
-    metadata: dict
-
-    def has_content(self) -> bool:
-        return len(self.content) > 0
-
-    def content_at(self, index: int) -> Content:
-        if len(self.content) < index + 1:
-            raise ExpectedContentException(index, len(self.content))
-        return self.content[index]
-
-    def first_content(self):
-        return self.content_at(0)
-
-    def get_metadata(self, key: str):
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            raise MissingMetadataException(key)
-
-    def get_metadata_or_else(self, key: str, default: str) -> str:
-        if key in self.metadata:
-            return self.metadata[key]
-        else:
-            return default
-
-
 class TransformInput(NamedTuple):
     content: List[Content]
     metadata: dict
@@ -209,8 +50,3 @@ class TransformInput(NamedTuple):
             return self.metadata[key]
         else:
             return default
-
-
-class ValidateInput(NamedTuple):
-    content: Content
-    metadata: dict

deltafi/plugin.py

@@ -165,8 +165,6 @@ class Plugin(object):
             'name': self.action_name(action),
             'description': action.description,
             'type': action.action_type.name,
-            'requiresDomains': action.requires_domains,
-            'requiresEnrichments': action.requires_enrichments,
             'schema': action.param_class().model_json_schema()
         }
 

deltafi/result.py

@@ -46,21 +46,6 @@ class Result:
         self.metrics.append(metric)
 
 
-class DomainResult(Result):
-    def __init__(self, context: Context):
-        super().__init__('domain', 'DOMAIN', context)
-        self.annotations = {}
-
-    def annotate(self, key: str, value: str):
-        self.annotations[key] = value
-        return self
-
-    def response(self):
-        return {
-            'annotations': self.annotations
-        }
-
-
 class EgressResult(Result):
     def __init__(self, context: Context, destination: str, bytes_egressed: int):
         super().__init__(None, 'EGRESS', context)
@@ -71,31 +56,6 @@ class EgressResult(Result):
         return None
 
 
-class EnrichResult(Result):
-    def __init__(self, context: Context):
-        super().__init__('enrich', 'ENRICH', context)
-        self.enrichments = []
-        self.annotations = {}
-
-    def enrich(self, name: str, value: str, media_type: str):
-        self.enrichments.append({
-            'name': name,
-            'value': value,
-            'mediaType': media_type
-        })
-        return self
-
-    def annotate(self, key: str, value: str):
-        self.annotations[key] = value
-        return self
-
-    def response(self):
-        return {
-            'enrichments': self.enrichments,
-            'annotations': self.annotations
-        }
-
-
 class ErrorResult(Result):
     def __init__(self, context: Context, error_cause: str, error_context: str):
         super().__init__('error', 'ERROR', context)
@@ -134,80 +94,6 @@ class FilterResult(Result):
         }
 
 
-class FormatResult(Result):
-    def __init__(self, context: Context):
-        super().__init__('format', 'FORMAT', context)
-        self.content = None
-        self.delete_metadata_keys = []
-        self.metadata = {}
-
-    def set_metadata(self, metadata: dict):
-        self.metadata = metadata
-        return self
-
-    def add_metadata(self, key: str, value: str):
-        self.metadata[key] = value
-        return self
-
-    def delete_metadata_key(self, key: str):
-        self.delete_metadata_keys.append(key)
-        return self
-
-    def set_content(self, content: Content):
-        self.content = content
-        return self
-
-    def save_string_content(self, string_data: str, name: str, media_type: str):
-        segment = self.context.content_service.put_str(self.context.did, string_data)
-        self.content = Content(name=name, segments=[segment], media_type=media_type,
-                               content_service=self.context.content_service)
-        return self
-
-    def save_byte_content(self, byte_data: bytes, name: str, media_type: str):
-        segment = self.context.content_service.put_bytes(self.context.did, byte_data)
-        self.content = Content(name=name, segments=[segment], media_type=media_type,
-                               content_service=self.context.content_service)
-        return self
-
-    def response(self):
-        return {
-            'content': self.content.json(),
-            'metadata': self.metadata,
-            'deleteMetadataKeys': self.delete_metadata_keys
-        }
-
-
-class ChildFormatResult:
-    def __init__(self, format_result: FormatResult = None):
-        self._did = str(uuid.uuid4())
-        self.format_result = format_result
-
-    @property
-    def did(self):
-        return self._did
-
-    def response(self):
-        res = self.format_result.response()
-        res["did"] = self._did
-        return res
-
-
-class FormatManyResult(Result):
-    def __init__(self, context: Context):
-        super().__init__('formatMany', 'FORMAT_MANY', context)
-        self.format_results = []
-
-    def add_format_result(self, format_result):
-        if isinstance(format_result, ChildFormatResult):
-            self.format_results.append(format_result)
-        else:
-            self.format_results.append(ChildFormatResult(format_result))
-        return self
-
-    def response(self):
-        return [format_result.response() for format_result in self.format_results]
-
-
 class IngressResultItem:
     def __init__(self, context: Context, filename: str):
         self.context = context
@@ -288,129 +174,6 @@ class IngressResult(Result):
         }
 
 
-class LoadResult(Result):
-    def __init__(self, context: Context):
-        super().__init__('load', 'LOAD', context)
-        self.content = []
-        self.metadata = {}
-        self.domains = []
-        self.annotations = {}
-        self.delete_metadata_keys = []
-
-    # content can be a single Content or a List[Content]
-    def add_content(self, content):
-        if content:
-            if type(content) == list:
-                self.content.extend(content)
-            else:
-                self.content.append(content)
-
-        return self
-
-    def save_string_content(self, string_data: str, name: str, media_type: str):
-        segment = self.context.content_service.put_str(self.context.did, string_data)
-        self.content.append(
-            Content(name=name, segments=[segment], media_type=media_type, content_service=self.context.content_service))
-        return self
-
-    def save_byte_content(self, byte_data: bytes, name: str, media_type: str):
-        segment = self.context.content_service.put_bytes(self.context.did, byte_data)
-        self.content.append(
-            Content(name=name, segments=[segment], media_type=media_type, content_service=self.context.content_service))
-        return self
-
-    def set_metadata(self, metadata: dict):
-        self.metadata = metadata
-        return self
-
-    def add_metadata(self, key: str, value: str):
-        self.metadata[key] = value
-        return self
-
-    def add_domain(self, name: str, value: str, media_type: str):
-        self.domains.append({
-            'name': name,
-            'value': value,
-            'mediaType': media_type})
-        return self
-
-    def annotate(self, key: str, value: str):
-        self.annotations[key] = value
-        return self
-
-    def delete_metadata_key(self, key: str):
-        self.delete_metadata_keys.append(key)
-        return self
-
-    def response(self):
-        return {
-            'domains': self.domains,
-            'content': [content.json() for content in self.content],
-            'metadata': self.metadata,
-            'annotations': self.annotations,
-            'deleteMetadataKeys': self.delete_metadata_keys
-        }
-
-
-class ChildLoadResult:
-    def __init__(self, load_result: LoadResult = None):
-        self._did = str(uuid.uuid4())
-        self.load_result = load_result
-
-    @property
-    def did(self):
-        return self._did
-
-    def response(self):
-        res = self.load_result.response()
-        res["did"] = self._did
-        return res
-
-
-class LoadManyResult(Result):
-    def __init__(self, context: Context):
-        super().__init__('loadMany', 'LOAD_MANY', context)
-        self.load_results = []
-
-    def add_load_result(self, load_result):
-        if isinstance(load_result, ChildLoadResult):
-            self.load_results.append(load_result)
-        else:
-            self.load_results.append(ChildLoadResult(load_result))
-        return self
-
-    def response(self):
-        return [load_result.response() for load_result in self.load_results]
-
-
-class ReinjectResult(Result):
-    class ReinjectChild:
-        def __init__(self, filename: str, flow: str, content: List[Content], metadata: Dict[str, str]):
-            self.filename = filename
-            self.flow = flow
-            self.content = content
-            self.metadata = metadata
-
-        def json(self):
-            return {
-                'filename': self.filename,
-                'flow': self.flow,
-                'metadata': self.metadata,
-                'content': [content.json() for content in self.content]
-            }
-
-    def __init__(self, context: Context):
-        super().__init__('reinject', 'REINJECT', context)
-        self.children = []
-
-    def add_child(self, filename: str, flow: str, content: List[Content], metadata: Dict[str, str]):
-        child = ReinjectResult.ReinjectChild(filename, flow, content, metadata)
-        self.children.append(child)
-
-    def response(self):
-        return [child.json() for child in self.children]
-
-
 class TransformResult(Result):
     def __init__(self, context: Context):
         super().__init__('transform', 'TRANSFORM', context)
@@ -464,11 +227,3 @@ class TransformResult(Result):
             'annotations': self.annotations,
             'deleteMetadataKeys': self.delete_metadata_keys
         }
-
-
-class ValidateResult(Result):
-    def __init__(self, context: Context):
-        super().__init__(None, 'VALIDATE', context)
-
-    def response(self):
-        return None

{deltafi-1.1.16.dist-info → deltafi-2.0rc1705013410531.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltafi
-Version: 1.1.16
+Version: 2.0rc1705013410531
 Summary: SDK for DeltaFi plugins and actions
 License: Apache License, Version 2.0
 Keywords: deltafi

{deltafi-1.1.16.dist-info → deltafi-2.0rc1705013410531.dist-info}/RECORD

@@ -1,24 +1,22 @@
 deltafi/__init__.py,sha256=qv6y7PpBG0ekTN9EuD9Lj8JYOLVqZA6tvHwgjplncAM,709
-deltafi/action.py,sha256=TM8HwfC12GgfHMBWPmO88N7J9xvwGO8BMwxKTNqwg9A,10498
+deltafi/action.py,sha256=cjnRsmBNCSCosFipIS_UXMHKC5MRITVSdc6MIeYUyL4,5305
 deltafi/actioneventqueue.py,sha256=mCRE1PFXy_KvaeezTeMze5N400CO1V06zEF8FFD6xZk,2847
-deltafi/actiontype.py,sha256=SgCxs5Kn_6BuzuKDk5h93ZLtfdbzV0sWLcEaaB0mqlU,997
+deltafi/actiontype.py,sha256=6OoZNEMcreD5f_QaGhTu8MEYLr3CalzcNu9XuFx40zg,865
 deltafi/domain.py,sha256=M97_n6KsMmIxCh3h622jNj1n6c5iMEAOn-SFH36oLis,12161
 deltafi/exception.py,sha256=qQ2TY2QPtMU9t5RH8jmFo_cX98AJ-zOFWP_Wfm5U6qQ,1149
 deltafi/genericmodel.py,sha256=8VXWgFMjIwG4o3rkcLOa3bQH0Nf-T1Kw621QtMw-4q0,1090
-deltafi/input.py,sha256=DuY280ZglZxEUkhjTtyr0g9Ohu2drn16UVhASH244nA,6290
+deltafi/input.py,sha256=2qQcOWqz7lOXZIZipTz5XtcGESpjdnUAsZ7b9YqHw7M,1656
 deltafi/logger.py,sha256=q76R_Gn8BfcASH3Zy0V82m5ot34bjTnSELyKbjhvx3E,2136
 deltafi/metric.py,sha256=eIDjZQVO53KuAFoEtjLNFwqMrp_7BC0Td9GLD1tb6sE,967
-deltafi/plugin.py,sha256=GkDq9oc5O0QYUZ7CdYcP1f9zRT38ufvzudZ4addHVS8,13076
-deltafi/result.py,sha256=KkFKewPxcP8_Slp0D2COJ43h5_fF5Vti9ocWtp8pjpc,14911
+deltafi/plugin.py,sha256=LTkAII2ur6BFylxnp80slzximkDyKr5bvHEzczR9C4U,12956
+deltafi/result.py,sha256=2r3BKNQntlMpFXZtYOm7skoLzBocDRBwtRP3oRkGrfc,7330
 deltafi/storage.py,sha256=toq58EPZgzj2TfDF-YpFUmRnsWSjACA0KQAZzkM04xU,2740
 deltafi/test_kit/__init__.py,sha256=qv6y7PpBG0ekTN9EuD9Lj8JYOLVqZA6tvHwgjplncAM,709
 deltafi/test_kit/assertions.py,sha256=2eahqmbedhnHXMguiJHdaV-6sx4_jvCbxH4HSzx6PV8,1378
 deltafi/test_kit/compare_helpers.py,sha256=Oi07zsq7jlpAHxqjwHsea84acC3lAL3ooG0VC42lLAc,1581
 deltafi/test_kit/constants.py,sha256=epz0OS-qILcc8t7iIs5B3m2-wvZx8FpYpyb19ZsImbI,833
-deltafi/test_kit/format.py,sha256=YkF8VGuDp6fOxria332zoQJarmmPaN6fTjTuumzyMLI,4071
 deltafi/test_kit/framework.py,sha256=R07AH4zxWXaJ3QNufGrtiOvdZrZKEoo2FtZLGmgAnRk,13062
-deltafi/test_kit/load.py,sha256=W8LRW1-NYHdjPB9UJ7kAAKblv883Ke39v4jewwbfm60,4855
 deltafi/test_kit/transform.py,sha256=x2TNTV39TmJQbVImm-sOfUlS_qaWcDRi5mfK4ZE0ONE,2608
-deltafi-1.1.16.dist-info/METADATA,sha256=Y3plfdN9TFiogOxnhxuUwM-IMyvypRfi5ryP-WLV9kM,1484
-deltafi-1.1.16.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-deltafi-1.1.16.dist-info/RECORD,,
+deltafi-2.0rc1705013410531.dist-info/METADATA,sha256=Qnqr2rCpU5PnXE1uJti_UH_Kiz2hVKqvsZHm1iA_BBg,1496
+deltafi-2.0rc1705013410531.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+deltafi-2.0rc1705013410531.dist-info/RECORD,,

deltafi/test_kit/format.py

@@ -1,100 +0,0 @@
-#
-#    DeltaFi - Data transformation and enrichment platform
-#
-#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
-#
-#    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.
-#
-
-from typing import List
-
-from deltafi.result import FormatResult, FormatManyResult
-
-from .assertions import *
-from .framework import TestCaseBase, ActionTest
-
-
-class FormatTestCase(TestCaseBase):
-    def __init__(self, fields: Dict):
-        super().__init__(fields)
-        self.metadata = {}
-        self.delete_metadata_keys = []
-        self.expected_format_many_result = []
-
-    def expect_format_result(self, metadata: Dict, delete_metadata_keys: List[str]):
-        self.expected_result_type = FormatResult
-        self.metadata = metadata
-        self.delete_metadata_keys = delete_metadata_keys
-
-    def add_format_many_result(self, metadata: Dict, delete_metadata_keys: List):
-        self.expected_result_type = FormatManyResult
-        self.expected_format_many_result.append(
-            {
-                "metadata": metadata,
-                "delete_metadata_keys": delete_metadata_keys
-            }
-        )
-
-
-class FormatActionTest(ActionTest):
-    def __init__(self, package_name: str):
-        """
-        Provides structure for testing DeltaFi Format action
-        Args:
-            package_name: name of the actions package for finding resources
-        """
-        super().__init__(package_name)
-
-    def format(self, test_case: FormatTestCase):
-        if test_case.expected_result_type == FormatManyResult:
-            self.expect_format_many_result(test_case)
-        elif test_case.expected_result_type == FormatResult:
-            self.expect_format_result(test_case)
-        else:
-            super().execute(test_case)
-
-    def expect_format_result(self, test_case: FormatTestCase):
-        result = super().run_and_check_result_type(test_case, FormatResult)
-        self.assert_format_result(test_case, result)
-
-    def expect_format_many_result(self, test_case: FormatTestCase):
-        result = super().run_and_check_result_type(test_case, FormatManyResult)
-        self.assert_format_many_result(test_case, result)
-
-    def assert_format_result(self, test_case: FormatTestCase, result: FormatResult):
-        # Check output
-        if result.content is None:
-            self.compare_all_output(test_case.compare_tool, [])
-        else:
-            self.compare_all_output(test_case.compare_tool, [result.content])
-
-        # Check metadata
-        assert_keys_and_values(test_case.metadata, result.metadata)
-
-        # Check deleted metadata
-        for key in test_case.delete_metadata_keys:
-            assert_key_in(key, result.delete_metadata_keys)
-
-    def assert_format_many_result(self, test_case: FormatTestCase, actual: FormatManyResult):
-        assert_equal_len(test_case.expected_format_many_result, actual.format_results)
-        for index, expected_child_result in enumerate(test_case.expected_format_many_result):
-            actual_child = actual.format_results[index]
-            self.compare_one_content(test_case.compare_tool,
-                                     self.expected_outputs[index],
-                                     actual_child.format_result.content,
-                                     index)
-
-            assert_keys_and_values(expected_child_result['metadata'],
-                                   actual_child.format_result.metadata)
-            for key in expected_child_result['delete_metadata_keys']:
-                assert_key_in(key, actual_child.format_result.delete_metadata_keys)

deltafi/test_kit/load.py

@@ -1,122 +0,0 @@
-#
-#    DeltaFi - Data transformation and enrichment platform
-#
-#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
-#
-#    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.
-#
-
-from typing import List
-
-from deltafi.result import LoadResult, ReinjectResult
-
-from .assertions import *
-from .compare_helpers import GenericCompareHelper, CompareHelper
-from .framework import TestCaseBase, ActionTest, IOContent
-
-
-class LoadTestCase(TestCaseBase):
-    def __init__(self, fields: Dict):
-        super().__init__(fields)
-        self.metadata = {}
-        self.delete_metadata_keys = []
-        self.annotations = {}
-        self.domains = []
-        self.domain_cmp_tool = GenericCompareHelper()
-        self.children = []
-
-    def set_domain_compare_tool(self, helper: CompareHelper):
-        self.domain_cmp_tool = helper
-
-    def expect_load_result(self, metadata: Dict, delete_metadata_keys: List[str], annotations: Dict, domains: List):
-        self.expected_result_type = LoadResult
-        self.metadata = metadata
-        self.delete_metadata_keys = delete_metadata_keys
-        self.annotations = annotations
-        self.domains = domains
-
-    def add_reinject_child(self, filename: str, flow: str, content: IOContent, metadata: Dict):
-        self.expected_result_type = ReinjectResult
-        self.children.append(
-            {
-                "filename": filename,
-                "flow": flow,
-                "content": content,
-                "metadata": metadata
-            }
-        )
-
-
-class LoadActionTest(ActionTest):
-    def __init__(self, package_name: str):
-        """
-        Provides structure for testing DeltaFi Load action
-        Args:
-            package_name: name of the actions package for finding resources
-        """
-        super().__init__(package_name)
-
-    def load(self, test_case: LoadTestCase):
-        if test_case.expected_result_type == ReinjectResult:
-            self.expect_reinject_result(test_case)
-        elif test_case.expected_result_type == LoadResult:
-            self.expect_load_result(test_case)
-        else:
-            super().execute(test_case)
-
-    def expect_load_result(self, test_case: LoadTestCase):
-        result = super().run_and_check_result_type(test_case, LoadResult)
-        self.assert_load_result(test_case, result)
-
-    def expect_reinject_result(self, test_case: LoadTestCase):
-        result = super().run_and_check_result_type(test_case, ReinjectResult)
-        self.assert_reinject_result(test_case, result)
-
-    def assert_load_result(self, test_case: LoadTestCase, result: LoadResult):
-        # Check output
-        self.compare_all_output(test_case.compare_tool, result.content)
-
-        # Check metadata
-        assert_keys_and_values(test_case.metadata, result.metadata)
-
-        # Check deleted metadata
-        for key in test_case.delete_metadata_keys:
-            assert_key_in(key, result.delete_metadata_keys)
-
-        # Check annotations
-        assert_keys_and_values(test_case.annotations, result.annotations)
-
-        # Check domains
-        self.compare_domains(test_case.domain_cmp_tool, test_case.domains, result.domains)
-
-    def assert_reinject_result(self, test_case: LoadTestCase, actual: ReinjectResult):
-        assert_equal_len(test_case.children, actual.children)
-        for index, expected in enumerate(test_case.children):
-            reinject_child = actual.children[index]
-            assert_equal(expected['filename'], reinject_child.filename)
-            assert_equal(expected['flow'], reinject_child.flow)
-            assert_keys_and_values(expected['metadata'], reinject_child.metadata)
-
-            expected_value = expected['content']
-            child_content = reinject_child.content[0]
-            seg_id = child_content.segments[0].uuid
-            actual_content = self.content_service.get_output(seg_id)
-
-            if type(expected_value) == str:
-                test_case.domain_cmp_tool.compare(expected_value, actual_content, f"RI_child[{index}]")
-            elif type(expected_value) == IOContent:
-                expected_data = self.load_file(expected_value)
-                test_case.domain_cmp_tool.compare(expected_data, actual_content, f"RI_child[{index}]")
-            else:
-                raise ValueError(
-                    f"unknown expected_value type: {type(expected_value)}")