AWSGlueDataplanePython 5.0.0__py3-none-any.whl

awsglue/scripts/scripts_utils.py

@@ -0,0 +1,106 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+import os
+from awsglue.context import GlueContext
+from awsglue.dynamicframe import DynamicFrame
+from awsglue.transforms import get_transform
+from pyspark.sql.types import *
+from pyspark.sql.functions import *
+
+COLLECT_RESULT_NAME = "collect_list(named_struct(NamePlaceholder(), unresolvedstar()))"
+DEFAULT_CATALOG_ENDPOINT = 'daylight-gamma'
+DEFAULT_GLUE_ENDPOINT = 'glue-beta'
+DEFAULT_REGION = 'us-east-1'
+
+def write_backup(data, database_name, backup_location, glue_context):
+    nested_tables = nest_data_frame(_order_columns_for_backup(data['table']), database_name, 'table')
+    nested_partitions = nest_data_frame(_order_columns_for_backup(data['partition']), database_name, 'partition')
+    write_df_to_s3(
+            glue_context,
+            nested_tables.withColumn("table",lit("empty")).select(col("table"),("items"),("database"),("type")).union(nested_partitions),
+            backup_location
+    )
+
+def _order_columns_for_backup(dataframe):
+    return dataframe.select(
+        col('name'),
+        col('description'),
+        col('owner'),
+        col('createTime'),
+        col('updateTime'),
+        col('lastAccessTime'),
+        col('lastAnalyzedTime'),
+        col('retention'),
+        col('storageDescriptor'),
+        col('partitionKeys'),
+        col('tableType'),
+        col('parameters'),
+        col('createdBy'),
+        col('values'),
+        col('namespaceName'),
+        col('tableName'),
+        col('table')
+    )
+
+def nest_data_frame(data_frame, database_name, entity_type):
+    if entity_type.startswith("table"):
+        # Entity is a table
+        return data_frame.agg(collect_list(struct("*"))).withColumnRenamed(COLLECT_RESULT_NAME, "items").withColumn("database",lit(database_name)).withColumn("type", lit(entity_type))
+    elif entity_type.startswith("partition"):
+        # Entity is a partition
+        return data_frame.groupBy('tableName').agg(collect_list(struct("*"))).withColumnRenamed(COLLECT_RESULT_NAME, "items").withColumn("database",lit(database_name)).withColumn("type", lit(entity_type)).withColumnRenamed("tableName","table")
+    elif entity_type.startswith("database"):
+        return data_frame.groupBy().agg(collect_list(struct("*"))).withColumnRenamed(COLLECT_RESULT_NAME, "items").withColumn("type", lit(entity_type))
+    else:
+        raise Exception("entity_type %s is not recognized, your backup data may be corrupted..." % entity_type)
+
+def write_df_to_catalog(data_frame, entity_type, glue_context, options):
+    # Check if data frame is empty. There is no "empty" method for data frame, this is the closest we get.
+    if data_frame.rdd.isEmpty():
+        return # nothing to do
+    database_name = options['catalog.database']
+    nested_data_frame = nest_data_frame(data_frame, database_name, entity_type)
+    dynamic_frame = DynamicFrame.fromDF(nested_data_frame, glue_context, entity_type)
+    sink = glue_context.getSink('catalog', **options)
+    sink.write(dynamic_frame)
+
+def catalog_dict(data_frame):
+    databases = data_frame.filter("type = 'database'").select(explode(data_frame['items'])).select(col("col.*"))
+    tables = data_frame.filter("type = 'table'").select(explode(data_frame['items'])).select(col("col.*"))
+    table_versions = data_frame.filter("type = 'tableVersion'").select(explode(data_frame['items'])).select(col("col.*"))
+    partitions = data_frame.filter("type = 'partition'").select(explode(data_frame['items'])).select(col("col.*"))
+    tables_to_delete = data_frame.filter("type = 'tableToDelete'").select(explode(data_frame['items'])).select(col("col.*"))
+    partitions_to_delete = data_frame.filter("type = 'partitionToDelete'").select(explode(data_frame['items'])).select(col("col.*"))
+    return {
+        'database' : databases,
+        'table' : tables,
+        'tableVersion' : table_versions,
+        'partition' : partitions,
+        'tableToDelete' : tables_to_delete,
+        'partitionToDelete' : partitions_to_delete
+    }    
+
+def read_from_catalog(glue_context, options):
+    return catalog_dict(glue_context.create_dynamic_frame_from_options(
+    connection_type="com.amazonaws.services.glue.connections.DataCatalogConnection", connection_options=options).toDF())
+
+def write_df_to_s3(glue_context, data_frame, backup_location):
+    dynamic_frame = DynamicFrame.fromDF(data_frame, glue_context, "toS3")
+    sink = glue_context.getSink("s3", path=backup_location)
+    sink.setFormat("json")
+    sink.write(dynamic_frame)
+
+def read_from_s3(glue_context, backup_location):
+    src = glue_context.getSource("file", paths=[backup_location])
+    src.setFormat('json')
+    return catalog_dict(src.getFrame().toDF())

awsglue/streaming_data_source.py

@@ -0,0 +1,28 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from awsglue.utils import makeOptions, callsite
+from pyspark.sql import DataFrame
+
+class StreamingDataSource(object):
+    def __init__(self, j_source, sql_ctx, name):
+        self._jsource = j_source
+        self._sql_ctx = sql_ctx
+        self.name = name
+
+    def setFormat(self, format, **options):
+        options["callSite"] = callsite()
+        self._jsource.setFormat(format, makeOptions(self._sql_ctx._sc, options))
+
+    def getFrame(self):
+        jdf = self._jsource.getDataFrame()
+        return DataFrame(jdf, self._sql_ctx)

awsglue/transforms/__init__.py

@@ -0,0 +1,47 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from .transform import GlueTransform
+from .unbox import Unbox
+from .unnest_frame import UnnestFrame
+from .relationalize import Relationalize
+from .field_transforms import RenameField, DropFields, SelectFields, SplitFields, SplitRows, Join, Spigot
+from .collection_transforms import SelectFromCollection, MapToCollection, FlatMap
+from .drop_nulls import DropNullFields
+from .apply_mapping import ApplyMapping
+from .repartition import Repartition
+from .resolve_choice import ResolveChoice
+from .errors_as_dynamicframe import ErrorsAsDynamicFrame
+from .dynamicframe_filter import Filter
+from .dynamicframe_map import Map
+from .coalesce import Coalesce
+from .union import Union
+import json
+
+ALL_TRANSFORMS = {Unbox, RenameField, DropFields, SplitFields, SelectFields, SplitRows,
+                  UnnestFrame, Relationalize, SelectFromCollection,
+                  MapToCollection, ErrorsAsDynamicFrame, FlatMap, DropNullFields,
+                  Join, ApplyMapping, Repartition, ResolveChoice, Spigot, Filter, Map, Coalesce, Union}
+
+__all__ = [transform.__name__ for transform in ALL_TRANSFORMS]
+
+def get_transforms():
+    return {transform() for transform in ALL_TRANSFORMS}
+
+def get_transform(name):
+    transform, = [t for t in get_transforms() if t.name().lower() == name.lower()] or (None,)
+    return transform
+
+def describe_transform(name):
+    transform = get_transform(name)
+    description = transform.describe() if transform else {}
+    return json.dumps(description, sort_keys=True, indent=4, separators=(',', ': '))

awsglue/transforms/apply_mapping.py

@@ -0,0 +1,72 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from awsglue.transforms import DropFields, GlueTransform
+
+class ApplyMapping(GlueTransform):
+    def __call__(self, frame, mappings, case_sensitive = False,
+                 transformation_ctx = "", info = "", stageThreshold = 0, totalThreshold = 0):
+        return frame.apply_mapping(mappings, case_sensitive, transformation_ctx,
+                                   info, stageThreshold, totalThreshold)
+
+    @classmethod
+    def describeArgs(cls):
+        arg1 = {"name": "frame",
+                "type": "DynamicFrame",
+                "description": "DynamicFrame to transform",
+                "optional": False,
+                "defaultValue": None}
+        arg2 = {"name": "mappings",
+                "type": "DynamicFrame",
+                "description": "List of mapping tuples (source col, source type, target col, target type)",
+                "optional": False,
+                "defaultValue": None}
+        arg3 = {"name": "case_sensitive",
+                "type": "Boolean",
+                "description": "Whether ",
+                "optional": True,
+                "defaultValue": "False"}
+        arg4 = {"name": "transformation_ctx",
+                "type": "String",
+                "description": "A unique string that is used to identify stats / state information",
+                "optional": True,
+                "defaultValue": ""}
+        arg5 = {"name": "info",
+                "type": "String",
+                "description": "Any string to be associated with errors in the transformation",
+                "optional": True,
+                "defaultValue": "\"\""}
+        arg6 = {"name": "stageThreshold",
+                "type": "Integer",
+                "description": "Max number of errors in the transformation until processing will error out",
+                "optional": True,
+                "defaultValue": "0"}
+        arg7 = {"name": "totalThreshold",
+                "type": "Integer",
+                "description": "Max number of errors total until processing will error out.",
+                "optional": True,
+                "defaultValue": "0"}
+
+        return [arg1, arg2, arg3, arg4, arg5, arg6, arg7]
+
+    @classmethod
+    def describeTransform(cls):
+        return "Apply a declarative mapping to this DynamicFrame."
+
+    @classmethod
+    def describeErrors(cls):
+        return []
+
+    @classmethod
+    def describeReturn(cls):
+        return {"type": "DynamicFrame",
+                "description": "DynamicFrame after applying mappings."}

awsglue/transforms/coalesce.py

@@ -0,0 +1,66 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from awsglue.transforms import GlueTransform
+
+class Coalesce(GlueTransform):
+    def __call__(self, frame, num_partitions, shuffle = False, transformation_ctx = "", info = "",
+                 stageThreshold = 0, totalThreshold = 0):
+        return frame.coalesce(num_partitions, shuffle, transformation_ctx, info, stageThreshold, totalThreshold)
+
+    @classmethod
+    def describeArgs(cls):
+        arg1 = {"name": "num_partitions",
+                "type": "DynamicFrame",
+                "description": "Number of partitions",
+                "optional": False,
+                "defaultValue": None}
+        arg2 = {"name": "shuffle",
+                "type": "Boolean",
+                "description": "A boolean indicating whether shuffling enabled for the coalesce process",
+                "optional": True,
+                "defaultValue": False}
+        arg3 = {"name": "transformation_ctx",
+                "type": "String",
+                "description": "A unique string that is used to identify stats / state information",
+                "optional": True,
+                "defaultValue": ""}
+        arg4 = {"name": "info",
+                "type": "String",
+                "description": "Any string to be associated with errors in the transformation",
+                "optional": True,
+                "defaultValue": "\"\""}
+        arg5 = {"name": "stageThreshold",
+                "type": "Integer",
+                "description": "Max number of errors in the transformation until processing will error out",
+                "optional": True,
+                "defaultValue": "0"}
+        arg6 = {"name": "totalThreshold",
+                "type": "Integer",
+                "description": "Max number of errors total until processing will error out.",
+                "optional": True,
+                "defaultValue": "0"}
+
+        return [arg1, arg2, arg3, arg4, arg5, arg6]
+
+    @classmethod
+    def describeTransform(cls):
+        return "Coalesces a DynamicFrame."
+
+    @classmethod
+    def describeErrors(cls):
+        return []
+
+    @classmethod
+    def describeReturn(cls):
+        return {"type": "DynamicFrame",
+                "description": "The coalesced DynamicFrame."}

awsglue/transforms/collection_transforms.py

@@ -0,0 +1,155 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from awsglue.transforms import GlueTransform
+
+class SelectFromCollection(GlueTransform):
+
+    def __call__(self, dfc, key, transformation_ctx = ""):
+        return dfc.select(key, transformation_ctx)
+
+    @classmethod
+    def describeArgs(cls):
+        arg1 = {"name": "dfc",
+                "type": "DynamicFrameCollection",
+                "description": "select one DynamicFrame from this DynamicFrameCollection",
+                "optional": False,
+                "defaultValue": None}
+
+        arg2 = {"name": "key",
+                "type": "String",
+                "description": "The key to select",
+                "optional": False,
+                "defaultValue": None}
+
+        arg3 = {"name": "transformation_ctx",
+                "type": "String",
+                "description": "A unique string that is used to identify stats / state information",
+                "optional": True,
+                "defaultValue": ""}
+
+        return [arg1, arg2, arg3]
+
+    @classmethod
+    def describeTransform(cls):
+        return "Select one DynamicFrame out from the DynamicFrameCollection"
+
+    @classmethod
+    def describeErrors(cls):
+        return []
+
+    @classmethod
+    def describeReturn(cls):
+        return {"type": "DynamicFrame",
+                "description": "Dynamic Frame corresponding to name"}
+
+class MapToCollection(GlueTransform):
+
+    def __call__(self, dfc, callable, transformation_ctx = ""):
+        return dfc.map(callable, transformation_ctx)
+
+    @classmethod
+    def describeArgs(cls):
+        arg1 = {"name": "dfc",
+                "type": "CollectionDynamicFrame",
+                "description": "apply function on this DynamicFrameCollection",
+                "optional": False,
+                "defaultValue": None}
+
+        arg2 = {"name": "callable",
+                "type": "Callable",
+                "description": "apply this Callable on DynamicFrameCollection",
+                "optional": False,
+                "defaultValue": None}
+
+        arg3 = {"name": "transformation_ctx",
+                "type": "String",
+                "description": "A unique string that is used to identify stats / state information",
+                "optional": True,
+                "defaultValue": ""}
+
+        return [arg1, arg2, arg3]
+
+    @classmethod
+    def describeTransform(cls):
+        return "Apply a transform on each DynamicFrame of this DynamicFrameCollection"
+
+    @classmethod
+    def describeErrors(cls):
+        return []
+
+    @classmethod
+    def describeReturn(cls):
+        return {"type": "DynamicFrameCollection",
+                "description": "A new DynamicFrameCollection after apply transform on each element"}
+
+
+class FlatMap(GlueTransform):
+
+    def __call__(self, dfc, BaseTransform, frame_name, transformation_ctx = "", **base_kwargs):
+        args = {}
+
+        def apply_inner(frame, transformation_ctx):
+            args.clear()
+            args.update(base_kwargs)
+            args[frame_name] = frame
+            args["transformation_ctx"] = transformation_ctx
+            return BaseTransform.apply(**args)
+
+        return dfc.flatmap(apply_inner, transformation_ctx)
+
+    @classmethod
+    def describeArgs(cls):
+        arg1 = {"name": "dfc",
+                "type": "DynamicFrameCollection",
+                "description": "The collection over which to flatmap.",
+                "optional": False,
+                "defaultValue": None}
+
+        arg2 = {"name": "BaseTransform",
+                "type": "GlueTransform",
+                "description": "A GlueTransform to apply to each member of the collection.",
+                "optional": False,
+                "defaultValue": None}
+
+        arg3 = {"name": "frame_name",
+                "type": "String",
+                "description": "The argument name to which to pass the elements of the collection.",
+                "optional": False,
+                "defaultValue": None}
+
+        arg4 = {"name": "transformation_ctx",
+                "type": "String",
+                "description": "A unique string that is used to identify stats / state information",
+                "optional": True,
+                "defaultValue": ""}
+
+        arg5 = {"name": "base_kwargs",
+                "type": "dict",
+                "description": "Arguments to pass to the base transform.",
+                "optional": False,
+                "defaultValue": None}
+
+        return [arg1, arg2, arg3, arg4, arg5]
+
+    @classmethod
+    def describeTransform(cls):
+        return "Applies a transform to each DynamicFrame in a collection and flattens the results."
+
+    @classmethod
+    def describeErrors(cls):
+        return []
+
+    @classmethod
+    def describeReturn(cls):
+        return {"type": "DynamicFrameCollection",
+                "description": "A new DynamicFrameCollection after applying the transform on each element"}

awsglue/transforms/drop_nulls.py

@@ -0,0 +1,85 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from __future__ import print_function
+from awsglue.transforms import DropFields, GlueTransform
+from awsglue.gluetypes import ArrayType, NullType, StructType
+
+class DropNullFields(GlueTransform):
+    def _find_null_fields(self, ctx, schema, path, output):
+        if isinstance(schema, StructType):
+            for field in schema:
+                new_path = path + "." if path != "" else path
+                self._find_null_fields(ctx, field.dataType, new_path + ctx._jvm.RecordUtils.quoteName(field.name), output)
+
+        elif isinstance(schema, ArrayType):
+            # For the moment we only remove null fields in nested array columns.
+            # We don't change ArrayType(NullType).
+            if isinstance(schema.elementType, StructType):
+                self._find_null_fields(ctx, schema.elementType, path, output)
+
+        elif isinstance(schema, NullType):
+            output.append(path)
+
+        # Note: dropFields currently does not work through maps,
+        # so neither does DropNullFields
+
+    def __call__(self, frame, transformation_ctx = "", info = "", stageThreshold = 0, totalThreshold = 0):
+        null_fields = []
+        self._find_null_fields(frame.glue_ctx, frame.schema(), "", null_fields)
+        print("null_fields", null_fields)
+
+        return DropFields.apply(frame, null_fields, transformation_ctx,
+                                info, stageThreshold, totalThreshold)
+
+    @classmethod
+    def describeArgs(cls):
+        arg1 = {"name": "frame",
+                "type": "DynamicFrame",
+                "description": "Drop all null fields in this DynamicFrame",
+                "optional": False,
+                "defaultValue": None}
+        arg2 = {"name": "transformation_ctx",
+                "type": "String",
+                "description": "A unique string that is used to identify stats / state information",
+                "optional": True,
+                "defaultValue": ""}
+        arg3 = {"name": "info",
+                "type": "String",
+                "description": "Any string to be associated with errors in the transformation",
+                "optional": True,
+                "defaultValue": "\"\""}
+        arg4 = {"name": "stageThreshold",
+                "type": "Integer",
+                "description": "Max number of errors in the transformation until processing will error out",
+                "optional": True,
+                "defaultValue": "0"}
+        arg5 = {"name": "totalThreshold",
+                "type": "Integer",
+                "description": "Max number of errors total until processing will error out.",
+                "optional": True,
+                "defaultValue": "0"}
+
+        return [arg1, arg2, arg3, arg4, arg5]
+
+    @classmethod
+    def describeTransform(cls):
+        return "Drop all null fields in this DynamicFrame"
+
+    @classmethod
+    def describeErrors(cls):
+        return []
+
+    @classmethod
+    def describeReturn(cls):
+        return {"type": "DynamicFrame",
+                "description": "DynamicFrame without null fields."}

awsglue/transforms/dynamicframe_filter.py

@@ -0,0 +1,66 @@
+# Copyright 2016-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# Licensed under the Amazon Software License (the "License"). You may not use
+# this file except in compliance with the License. A copy of the License is
+# located at
+#
+#  http://aws.amazon.com/asl/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express
+# or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from awsglue.transforms import GlueTransform
+
+
+class Filter(GlueTransform):
+    def __call__(self, frame, f, transformation_ctx = "", info="", stageThreshold=0, totalThreshold=0):
+        return frame.filter(f, transformation_ctx, info, stageThreshold, totalThreshold)
+
+    @classmethod
+    def describeArgs(cls):
+        arg1 = {"name": "frame",
+                "type": "DynamicFrame",
+                "description": "The DynamicFrame to apply the Filter function",
+                "optional": False,
+                "defaultValue": None}
+        arg2 = {"name": "f",
+                "type": "Function",
+                "description": "Predicate function to call on the DynamicFrame. The function takes DynamicRecord as the argument and returns True/False",
+                "optional": False,
+                "defaultValue": None}
+        arg3 = {"name": "transformation_ctx",
+                "type": "String",
+                "description": "A unique string that is used to identify stats / state information",
+                "optional": True,
+                "defaultValue": ""}
+        arg4 = {"name": "info",
+                "type": "String",
+                "description": "Any string to be associated with errors in the transformation",
+                "optional": True,
+                "defaultValue": "\"\""}
+        arg5 = {"name": "stageThreshold",
+                "type": "Integer",
+                "description": "Max number of errors in the transformation until processing will error out",
+                "optional": True,
+                "defaultValue": "0"}
+        arg6 = {"name": "totalThreshold",
+                "type": "Integer",
+                "description": "Max number of errors total until processing will error out.",
+                "optional": True,
+                "defaultValue": "0"}
+
+        return [arg1, arg2, arg3, arg4, arg5, arg6]
+
+    @classmethod
+    def describeTransform(cls):
+        return "Builds a new DynamicFrame by selecting records from the input frame that satisfy the predicate function"
+
+    @classmethod
+    def describeErrors(cls):
+        return []
+
+    @classmethod
+    def describeReturn(cls):
+        return {"type": "DynamicFrame",
+                "description": "new DynamicFrame with DynamicRecords that matched the predicate"}