prosuite.factories package

issue_filters module

class prosuite.factories.issue_filters.IssueFilters

Bases: object

Noindex

Your existing documentation goes here.

classmethod not_yet_implemented(feature_class: BaseDataset, tolerance: float) → IssueFilter

Stay tuned

quality_conditions module

class prosuite.factories.quality_conditions.Conditions

Bases: object

classmethod qa3d_constant_z_0(feature_class: BaseDataset, tolerance: float) → Condition

Finds all points in ‘featureClass’ with a Z range larger than ‘tolerance’

classmethod qa_border_sense_0(polyline_class: BaseDataset, clockwise: bool) → Condition

Finds features that are not involved in valid rings: Checks if features in ‘polylineClass’ build rings and if the features in a ring are directed in clockwise / counterclockwise direction

classmethod qa_border_sense_1(polyline_classes: List[BaseDataset], clockwise: bool) → Condition

Finds features that are not involved in valid rings: Checks if features in ‘polylineClasses’ build rings and if the features in a ring are directed in clockwise / counterclockwise direction

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_centroids_0(polyline_class: BaseDataset, point_class: BaseDataset) → Condition

Finds errors in point-line-polygon topology: Checks if there is exactly one point from ‘pointClass’ within each polygon built by the features of ‘polylineClass’

Remark: The feature classes in ‘polylineClass’ and ‘pointClass’ must have the same spatial reference. The features of ‘polylineClass’ are not checked for intersections. Use QaLineIntersect to check

classmethod qa_centroids_1(polyline_class: BaseDataset, point_class: BaseDataset, constraint: str) → Condition

Finds errors in point-line-polygon topology: Checks if there is exactly one point from ‘pointClass’ within each polygon built by the features of ‘polylineClass’

Remark: The feature classes in ‘polylineClass’ and ‘pointClass’ must have the same spatial reference. The features of ‘polylineClass’ are not checked for intersections. Use QaLineIntersect to check

classmethod qa_centroids_2(polyline_classes: List[BaseDataset], point_classes: List[BaseDataset]) → Condition

Finds errors in point-line-polygon topology: Checks if there is exactly one point from ‘pointClasses’ within each polygon built by the features of ‘polylineClasses’

Remark: All feature classes in ‘polylineClasses’ and ‘pointClasses’ must have the same spatial reference. The features of ‘polylineClasses’ are not checked for intersections. Use QaLineIntersect to check

classmethod qa_centroids_3(polyline_classes: List[BaseDataset], point_classes: List[BaseDataset], constraint: str) → Condition

Finds errors in point-line-polygon topology: Checks if there is exactly one point from ‘pointClasses’ within each polygon built by the features of ‘polylineClasses’

Remark: All feature classes in ‘polylineClasses’ and ‘pointClasses’ must have the same spatial reference. The features of ‘polylineClasses’ are not checked for intersections. Use QaLineIntersect to check

classmethod qa_constraint_0(table: BaseDataset, constraint: str) → Condition

Finds all rows in ‘table’ that do not fulfill ‘constraint’

classmethod qa_constraints_list_factory(table: BaseDataset, constraints_table: BaseDataset, expression_field: str, expression_is_error: bool, description_field: str) → Condition

Finds rows in ‘table’ based on a list of expressions defined in another table. The expression table can be filtered to a subset of expressions relevant for the verified table.

classmethod qa_contained_points_count_0(polygon_class: BaseDataset, point_class: BaseDataset, expected_point_count: int, relevant_point_condition: str, polyline_usage: PolylineUsage = 0) → Condition

Finds polygons or polylines with an invalid number of contained points

classmethod qa_contained_points_count_1(polygon_class: BaseDataset, point_class: BaseDataset, minimum_point_count: int, maximum_point_count: int, relevant_point_condition: str, polyline_usage: PolylineUsage = 0) → Condition

Finds polygons or polylines with an invalid number of contained points

classmethod qa_contained_points_count_2(polygon_class: BaseDataset, point_class: BaseDataset, minimum_point_count: int, maximum_point_count: int, relevant_point_condition: str, count_point_on_polygon_border: bool, polyline_usage: PolylineUsage = 0) → Condition

Finds polygons or polylines with an invalid number of contained points

classmethod qa_contained_points_count_3(polygon_classes: List[BaseDataset], point_classes: List[BaseDataset], expected_point_count: int, relevant_point_condition: str, polyline_usage: PolylineUsage = 0) → Condition

Finds polygons or polylines with an invalid number of contained points

classmethod qa_contained_points_count_4(polygon_classes: List[BaseDataset], point_classes: List[BaseDataset], minimum_point_count: int, maximum_point_count: int, relevant_point_condition: str, count_point_on_polygon_border: bool, polyline_usage: PolylineUsage = 0) → Condition

Finds polygons or polylines with an invalid number of contained points

classmethod qa_contains_other_0(contains: List[BaseDataset], is_within: List[BaseDataset]) → Condition

Finds all features in ‘isWithin’ that are not contained by any feature in ‘contains’ Remarks: All feature classes in ‘contains’ and ‘isWithin’ must have the same spatial reference

classmethod qa_contains_other_1(contains: BaseDataset, is_within: BaseDataset) → Condition

Finds all features in ‘isWithin’ that are not contained by any feature in ‘contains’ Remarks: All feature classes in ‘contains’ and ‘isWithin’ must have the same spatial reference

classmethod qa_contains_other_2(contains: List[BaseDataset], is_within: List[BaseDataset], is_containing_condition: str, report_individual_parts: bool) → Condition

Finds all features in ‘isWithin’ that are not contained by any feature in ‘contains’ for which a given condition is fulfilled. Remarks: All feature classes in ‘contains’ and ‘isWithin’ must have the same spatial reference

classmethod qa_contains_other_3(contains: BaseDataset, is_within: BaseDataset, is_containing_condition: str, report_individual_parts: bool) → Condition

Finds all features in ‘isWithin’ that are not contained by any feature in ‘contains’ for which a given condition is fulfilled. Remarks: All feature classes in ‘contains’ and ‘isWithin’ must have the same spatial reference

classmethod qa_coplanar_rings_0(feature_class: BaseDataset, coplanarity_tolerance: float, include_associated_parts: bool) → Condition

Finds multipatch or polygon rings where its points are not coplanar

classmethod qa_crosses_other_0(crossed: List[BaseDataset], crossing: List[BaseDataset]) → Condition

Finds all features in ‘crossingClasses’ that are crossing any features of ‘crossedClasses’

Remark: All feature classes in ‘crossingClasses’ and ‘crossedClasses’ must have the same spatial reference.

classmethod qa_crosses_other_1(crossed: BaseDataset, crossing: BaseDataset) → Condition

Finds all features in ‘crossingClass’ that are crossing any features of ‘crossedClass’

Remark: The feature classes in ‘crossingClass’ and ‘crossedClass’ must have the same spatial reference.

classmethod qa_crosses_other_2(crossed_classes: List[BaseDataset], crossing_classes: List[BaseDataset], valid_relation_constraint: str) → Condition

Finds all features in ‘crossingClasses’ that are crossing any features of ‘crossedClasses’, and for which a given constraint is not fulfilled.

Remark: All feature classes in ‘crossingClasses’ and ‘crossedClasses’ must have the same spatial reference.

classmethod qa_crosses_other_3(crossed_class: BaseDataset, crossing_class: BaseDataset, valid_relation_constraint: str) → Condition

Finds all features in ‘crossingClass’ that are crossing any features of ‘crossedClass’, and for which a given constraint is not fulfilled.

Remark: The feature classes in ‘crossingClass’ and ‘crossedClass’ must have the same spatial reference.

classmethod qa_crosses_self_0(feature_classes: List[BaseDataset]) → Condition

Finds all features in ‘featureClasses’ that are crossing any features of ‘featureClasses’

classmethod qa_crosses_self_1(feature_class: BaseDataset) → Condition

Finds all features in ‘featureClass’ that are crossing any features of ‘featureClass’

classmethod qa_crosses_self_2(feature_classes: List[BaseDataset], valid_relation_constraint: str) → Condition

Finds all features in ‘featureClasses’ that are crossing any features of ‘featureClasses’, and for which a given constraint is not fulfilled.

classmethod qa_crosses_self_3(feature_class: BaseDataset, valid_relation_constraint: str) → Condition

Finds all features in ‘featureClass’ that are crossing any features of ‘featureClass’, and for which a given constraint is not fulfilled.

classmethod qa_curve_0(feature_class: BaseDataset, allowed_non_linear_segment_types: List[NonLinearSegmentType] = 0, group_issues_by_segment_type: bool = False) → Condition

Finds segments in ‘featureClass’ that are not straight lines

classmethod qa_dangle_count_0(polyline_class: BaseDataset, dangle_count_expression: str, tolerance: float) → Condition

Finds polyline features with a dangle count for which a given dangle count expression is not fulfilled. Dangles are defined as polyline end points that are not (within a specified tolerance) coincident with end points of other polylines.

classmethod qa_dangle_count_1(polyline_classes: List[BaseDataset], dangle_count_expressions: List[str], tolerance: float) → Condition

Finds polyline features with a dangle count for which a given dangle count expression is not fulfilled. Dangles are defined as polyline end points that are not (within a specified tolerance) coincident with end points of other polylines.

classmethod qa_dangle_factory(polyline_classes: List[BaseDataset]) → Condition

Finds all start/end points in ‘polylineClasses’ that connect to no other start/end point Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference

classmethod qa_dataset_constraint_factory(table: BaseDataset, constraint: List[str]) → Condition

Finds all rows in ‘table’ that do not fulfill the constraints

classmethod qa_date_fields_without_time_0(table: BaseDataset) → Condition

Finds rows with date fields having non-zero time parts. All date fields of the table are checked.

classmethod qa_date_fields_without_time_1(table: BaseDataset, date_field_name: str) → Condition

Finds rows that have non-zero time parts in a specified date field.

classmethod qa_date_fields_without_time_2(table: BaseDataset, date_field_names: List[str]) → Condition

Finds rows that have non-zero time parts in a given list of date fields.

classmethod qa_duplicate_geometry_self_0(feature_class: BaseDataset) → Condition

Finds features with equal geometries in a feature class. Geometries for which the difference geometry is empty are considered duplicates. Z and M values are therefore ignored, and the XY tolerance of the spatial reference is applied.

classmethod qa_duplicate_geometry_self_1(feature_class: BaseDataset, valid_duplicate_constraint: str) → Condition

Finds features with equal geometries in a feature class for which a given constraint is not fulfilled. Geometries for which the difference geometry is empty are considered duplicates. Z and M values are therefore ignored, and the XY tolerance of the spatial reference is applied.

classmethod qa_duplicate_geometry_self_2(feature_class: BaseDataset, valid_duplicate_constraint: str, report_single_error_per_duplicate_set: bool) → Condition

Finds features with equal geometries in a feature class for which a given constraint is not fulfilled. Geometries for which the difference geometry is empty are considered duplicates. Z and M values are therefore ignored, and the XY tolerance of the spatial reference is applied. Optionally, duplicates can be reported as a single error for the entire set of features that have an equal geometry.

classmethod qa_edge_match_bordering_lines_0(line_class1: BaseDataset, border_class1: BaseDataset, line_class2: BaseDataset, border_class2: BaseDataset, search_distance: float, line_class1_border_match_condition: Optional[str] = None, line_class2_border_match_condition: Optional[str] = None, bordering_line_match_condition: Optional[str] = None, bordering_line_attribute_constraint: Optional[str] = None, bordering_line_equal_attributes: Optional[str] = None, bordering_line_equal_attribute_options: Optional[List[str]] = None, report_individual_attribute_constraint_violations: bool = False, is_bordering_line_attribute_constraint_symmetric: bool = False, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, allow_no_feature_within_search_distance: bool = False, allow_non_coincident_end_points_on_border: bool = False, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds sections of polylines that follow along the border and have no suitable coincident polyline on the other side of the border that fulfills defined attribute matching rules.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the bordering polyline features are associated to their corresponding border by means of SQL expressions (‘LineClass1BorderMatchCondition’, ‘LineClass2BorderMatchCondition’). If the bordering polyline features are also stored in common feature classes, then the polyline feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘BorderingLineMatchCondition’). Using common feature classes for the border features/bordering polyline features in conjunction with the match conditions allows to verify borders between more than two areas using a single quality condition.

Only polyline features that have at least a partial linear intersection with the border geometry of their side are considered as candidates for bordering polylines. The identification of polylines that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a single polyline feature class per side.

classmethod qa_edge_match_bordering_lines_1(line_classes1: List[BaseDataset], border_class1: BaseDataset, line_classes2: List[BaseDataset], border_class2: BaseDataset, search_distance: float, line_class1_border_match_condition: Optional[str] = None, line_class2_border_match_condition: Optional[str] = None, bordering_line_match_condition: Optional[str] = None, bordering_line_attribute_constraint: Optional[str] = None, bordering_line_equal_attributes: Optional[str] = None, bordering_line_equal_attribute_options: Optional[List[str]] = None, report_individual_attribute_constraint_violations: bool = False, is_bordering_line_attribute_constraint_symmetric: bool = False, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, allow_no_feature_within_search_distance: bool = False, allow_non_coincident_end_points_on_border: bool = False, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds sections of polylines that follow along the border and have no suitable coincident polyline on the other side of the border that fulfills defined attribute matching rules.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the bordering polyline features are associated to their corresponding border by means of SQL expressions (‘LineClass1BorderMatchCondition’, ‘LineClass2BorderMatchCondition’). If the bordering polyline features are also stored in common feature classes, then the polyline feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘BorderingLineMatchCondition’). Using common feature classes for the border features/bordering polyline features in conjunction with the match conditions allows to verify borders between more than two areas using a single quality condition.

Only polyline features that have at least a partial linear intersection with the border geometry of their side are considered as candidates for bordering polylines. The identification of polylines that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a list of polyline feature classes per side.

classmethod qa_edge_match_bordering_points_0(point_class1: BaseDataset, border_class1: BaseDataset, point_class2: BaseDataset, border_class2: BaseDataset, search_distance: float, point_class1_border_match_condition: Optional[str] = None, point_class2_border_match_condition: Optional[str] = None, bordering_point_match_condition: Optional[str] = None, bordering_point_attribute_constraint: Optional[str] = None, is_bordering_point_attribute_constraint_symmetric: bool = False, bordering_point_equal_attributes: Optional[str] = None, bordering_point_equal_attribute_options: Optional[List[str]] = None, report_individual_attribute_constraint_violations: bool = False, coincidence_tolerance: float = 0, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, allow_no_feature_within_search_distance: bool = False, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds points located on the border which have no coincident corresponding point for the opposite side of the border that fulfills defined attribute matching rules.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the point features are associated to their corresponding border by means of SQL expressions (‘PointClass1BorderMatchCondition’, ‘PointClass2BorderMatchCondition’). If the bordering point features are also stored in common feature classes, then the point feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘BorderingPointMatchCondition’). Using common feature classes for the border features/bordering point features in conjunction with the match conditions allows to verify borders between more than two areas using a single quality condition.

Only point features located exactly on the border geometry of their side are considered as candidates for bordering points. The identification of points that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a single point feature class per side.

classmethod qa_edge_match_bordering_points_1(point_classes1: List[BaseDataset], border_class1: BaseDataset, point_classes2: List[BaseDataset], border_class2: BaseDataset, search_distance: float, point_class1_border_match_condition: Optional[str] = None, point_class2_border_match_condition: Optional[str] = None, bordering_point_match_condition: Optional[str] = None, bordering_point_attribute_constraint: Optional[str] = None, is_bordering_point_attribute_constraint_symmetric: bool = False, bordering_point_equal_attributes: Optional[str] = None, bordering_point_equal_attribute_options: Optional[List[str]] = None, report_individual_attribute_constraint_violations: bool = False, coincidence_tolerance: float = 0, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, allow_no_feature_within_search_distance: bool = False, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds points located on the border which have no coincident corresponding point for the opposite side of the border that fulfills defined attribute matching rules.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the point features are associated to their corresponding border by means of SQL expressions (‘PointClass1BorderMatchCondition’, ‘PointClass2BorderMatchCondition’). If the bordering point features are also stored in common feature classes, then the point feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘BorderingPointMatchCondition’). Using common feature classes for the border features/bordering point features in conjunction with the match conditions allows to verify borders between more than two areas using a single quality condition.

Only point features located exactly on the border geometry of their side are considered as candidates for bordering points. The identification of points that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a list of point feature classes per side.

classmethod qa_edge_match_crossing_areas_0(area_class1: BaseDataset, border_class1: BaseDataset, area_class2: BaseDataset, border_class2: BaseDataset, search_distance: float, bounding_classes1: List[BaseDataset], bounding_classes2: List[BaseDataset], area_class1_border_match_condition: Optional[str] = None, area_class1_bounding_feature_match_condition: Optional[str] = None, area_class2_bounding_feature_match_condition: Optional[str] = None, area_class2_border_match_condition: Optional[str] = None, crossing_area_match_condition: Optional[str] = None, crossing_area_attribute_constraint: Optional[str] = None, is_crossing_area_attribute_constraint_symmetric: bool = False, crossing_area_equal_attributes: Optional[str] = None, crossing_area_equal_attribute_options: List[str] = False, report_individual_attribute_constraint_violations: bool = False, allow_no_feature_within_search_distance: bool = False, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds polygons that touch the border and have no suitable connecting polygon on the other side of the border that fulfills defined attribute matching rules.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the crossing polygon features are associated to their corresponding border by means of SQL expressions (‘AreaClass1BorderMatchCondition’, ‘AreaClass2BorderMatchCondition’). If the crossing polygon features are also stored in common feature classes, then the polygon feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘CrossingAreaMatchCondition’). Using common feature classes for the border features/crossing polygon features in conjunction with these match conditions allows to verify borders between more than two areas using a single quality condition.

Only polygon features that have at least a partial linear intersection of their boundary with the border geometry of their side are considered as candidates for crossing polygons. The identification of polygons that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a single polygon feature class per side.

classmethod qa_edge_match_crossing_areas_1(area_classes1: List[BaseDataset], border_class1: BaseDataset, area_classes2: List[BaseDataset], border_class2: BaseDataset, search_distance: float, bounding_classes1: List[BaseDataset], bounding_classes2: List[BaseDataset], area_class1_border_match_condition: Optional[str] = None, area_class1_bounding_feature_match_condition: Optional[str] = None, area_class2_bounding_feature_match_condition: Optional[str] = None, area_class2_border_match_condition: Optional[str] = None, crossing_area_match_condition: Optional[str] = None, crossing_area_attribute_constraint: Optional[str] = None, is_crossing_area_attribute_constraint_symmetric: bool = False, crossing_area_equal_attributes: Optional[str] = None, crossing_area_equal_attribute_options: List[str] = False, report_individual_attribute_constraint_violations: bool = False, allow_no_feature_within_search_distance: bool = False, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds polygons that touch the border and have no suitable connecting polygon on the other side of the border that fulfills defined attribute matching rules.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the crossing polygon features are associated to their corresponding border by means of SQL expressions (‘AreaClass1BorderMatchCondition’, ‘AreaClass2BorderMatchCondition’). If the crossing polygon features are also stored in common feature classes, then the polygon feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘CrossingAreaMatchCondition’). Using common feature classes for the border features/crossing polygon features in conjunction with these match conditions allows to verify borders between more than two areas using a single quality condition.

Only polygon features that have at least a partial linear intersection of their boundary with the border geometry of their side are considered as candidates for crossing polygons. The identification of polygons that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a list of polygon feature classes per side.

classmethod qa_edge_match_crossing_lines_0(line_class1: BaseDataset, border_class1: BaseDataset, line_class2: BaseDataset, border_class2: BaseDataset, search_distance: float, minimum_error_connection_line_length: float = 0, maximum_end_point_connection_distance: float = 0, line_class1_border_match_condition: Optional[str] = None, line_class2_border_match_condition: Optional[str] = None, crossing_line_match_condition: Optional[str] = None, crossing_line_attribute_constraint: Optional[str] = None, is_crossing_line_attribute_constraint_symmetric: bool = False, crossing_line_equal_attributes: Optional[str] = None, crossing_line_equal_attribute_options: Optional[List[str]] = None, report_individual_attribute_constraint_violations: bool = False, coincidence_tolerance: float = 0, allow_no_feature_within_search_distance: bool = False, ignore_attribute_constraints_if_three_or_more_connected: bool = False, allow_no_feature_within_search_distance_if_connected_on_same_side: bool = True, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, ignore_neighbor_lines_with_border_connection_outside_search_distance: bool = True, allow_end_points_connecting_to_interior_of_valid_neighbor_line: bool = False, ignore_end_points_of_bordering_lines: bool = True, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds lines that end on the border which have no suitable connecting neighbor line on the other side of the border.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the crossing polyline features are associated to their corresponding border by means of SQL expressions (‘LineClass1BorderMatchCondition’, ‘LineClass2BorderMatchCondition’). If the crossing polyline features are also stored in common feature classes, then the polyline feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘CrossingLineMatchCondition’). Using common feature classes for the border features/crossing polyline features in conjunction with the match conditions allows to verify borders between more than two areas using a single quality condition.

Only polyline features that have at least one end point located exactly on the border geometry of their side are considered as candidates for crossing polylines. The identification of polyline end points that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a single polyline feature class per side.

classmethod qa_edge_match_crossing_lines_1(line_classes1: List[BaseDataset], border_class1: BaseDataset, line_classes2: List[BaseDataset], border_class2: BaseDataset, search_distance: float, minimum_error_connection_line_length: float = 0, maximum_end_point_connection_distance: float = 0, line_class1_border_match_condition: Optional[str] = None, line_class2_border_match_condition: Optional[str] = None, crossing_line_match_condition: Optional[str] = None, crossing_line_attribute_constraint: Optional[str] = None, is_crossing_line_attribute_constraint_symmetric: bool = False, crossing_line_equal_attributes: Optional[str] = None, crossing_line_equal_attribute_options: Optional[List[str]] = None, report_individual_attribute_constraint_violations: bool = False, coincidence_tolerance: float = 0, allow_no_feature_within_search_distance: bool = False, ignore_attribute_constraints_if_three_or_more_connected: bool = False, allow_no_feature_within_search_distance_if_connected_on_same_side: bool = True, allow_disjoint_candidate_feature_if_borders_are_not_coincident: bool = False, ignore_neighbor_lines_with_border_connection_outside_search_distance: bool = True, allow_end_points_connecting_to_interior_of_valid_neighbor_line: bool = False, ignore_end_points_of_bordering_lines: bool = True, allow_disjoint_candidate_feature_if_attribute_constraints_are_fulfilled: bool = False) → Condition

Finds lines that end on the border which have no suitable connecting neighbor line on the other side of the border.

Different border representations may be used for the respective sides, i.e. the borders are not required to be exactly coincident for this test to be applicable.

The border features may be stored either in two separate border feature classes, or in a common border feature class containing the borders for different areas. When using a common border feature class, the crossing polyline features are associated to their corresponding border by means of SQL expressions (‘LineClass1BorderMatchCondition’, ‘LineClass2BorderMatchCondition’). If the crossing polyline features are also stored in common feature classes, then the polyline feature pairs belonging to opposite sides of the border are also identified by an SQL expression (‘CrossingLineMatchCondition’). Using common feature classes for the border features/crossing polyline features in conjunction with the match conditions allows to verify borders between more than two areas using a single quality condition.

Only polyline features that have at least one end point located exactly on the border geometry of their side are considered as candidates for crossing polylines. The identification of polyline end points that are close to, but not exactly snapped to border geometries is possible using proximity tests.

Based on a list of polyline feature classes per side.

classmethod qa_empty_not_null_text_fields_0(table: BaseDataset) → Condition

Finds empty strings in non-nullable text fields

classmethod qa_empty_not_null_text_fields_1(table: BaseDataset, not_null_text_fields: List[str]) → Condition

Finds empty or NULL strings in a list of text fields

classmethod qa_export_tables_0(tables: List[BaseDataset], file_gdb_path: str, export_tile_ids: bool = False, export_tiles: bool = False) → Condition

Export ‘tables’ to a newly created file geodatabase

classmethod qa_extent_0(feature_class: BaseDataset, limit: float) → Condition

Finds all features in ‘featureClass’ where the largest extension of the bounding box is larger than ‘limit’

classmethod qa_extent_1(feature_class: BaseDataset, limit: float, per_part: bool) → Condition

Finds all features or feature parts in ‘featureClass’ where the largest extension of the bounding box is larger than ‘limit’.

classmethod qa_flow_logic_0(polyline_class: BaseDataset) → Condition

Finds all (From/To-) points in ‘polylineClass’, that are not coincident with exactly one From-point

classmethod qa_flow_logic_1(polyline_classes: List[BaseDataset]) → Condition

Finds all (From/To-) points in ‘polylineClasses’, that are not coincident with exactly one From-point

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_flow_logic_2(polyline_classes: List[BaseDataset], flip_expressions: List[str]) → Condition

Finds all (From/To-) points in ‘polylineClasses’, that are not coincident with exactly one From-point. From/To-Points are determined by ‘flipExpressions’.

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_flow_logic_3(polyline_classes: List[BaseDataset], flip_expressions: List[str], allow_multiple_outgoing_lines: bool) → Condition

Finds all (From/To-) points in ‘polylineClasses’, that are not coincident with exactly one From-point. From/To-Points are determined by ‘flipExpressions’.

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_foreign_key_0(table: BaseDataset, foreign_key_field: str, referenced_table: BaseDataset, referenced_key_field: str) → Condition

Finds rows that have a key value that does not refer to a value in a referenced table.

classmethod qa_foreign_key_1(table: BaseDataset, foreign_key_fields: List[str], referenced_table: BaseDataset, referenced_key_fields: List[str]) → Condition

Finds rows that have a key value combination that does not refer to a value combination in a referenced table.

classmethod qa_foreign_key_2(table: BaseDataset, foreign_key_fields: List[str], referenced_table: BaseDataset, referenced_key_fields: List[str], reference_is_error: bool) → Condition

Finds rows that have a key value combination that does not refer to a value combination in a referenced table. Optionally, an existing reference can be treated as an error.

classmethod qa_full_coincidence_0(feature_class: BaseDataset, reference: BaseDataset, near: float, is3_d: bool, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Finds all line parts in ‘featureClass’ that are further than ‘near’ from any feature of ‘reference’

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_full_coincidence_1(feature_class: BaseDataset, reference: BaseDataset, near: float, is3_d: bool, tile_size: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Finds all line parts in ‘featureClass’ that are further than ‘near’ from any feature of ‘reference’

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_full_coincidence_2(feature_class: BaseDataset, references: List[BaseDataset], near: float, is3_d: bool, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Finds all line parts in ‘featureClass’ that are further than ‘near’ from any feature of ‘references’

Remark: All feature classes in ‘featureClass’ and ‘references’ must have the same spatial reference.

classmethod qa_full_coincidence_3(feature_class: BaseDataset, references: List[BaseDataset], near: float, is3_d: bool, tile_size: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Finds all line parts in ‘featureClass’ that are further than ‘near’ from any feature of ‘references’

Remark: All feature classes in ‘featureClass’ and ‘references’ must have the same spatial reference.

classmethod qa_full_coincidence_4(feature_class: BaseDataset, references: List[BaseDataset], near: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Finds all line parts in ‘featureClass’ that are further than ‘near’ from any feature of ‘references’

Remark: All feature classes in ‘featureClass’ and ‘references’ must have the same spatial reference.

classmethod qa_full_coincidence_5(feature_class: BaseDataset, references: List[BaseDataset], near: float, tile_size: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Finds all line parts in ‘featureClass’ that are further than ‘near’ from any feature of ‘references’

Remark: All feature classes in ‘featureClass’ and ‘references’ must have the same spatial reference.

classmethod qa_gdb_constraint_0(table: BaseDataset) → Condition

Finds all rows in ‘table’ that do not fulfill the attribute rules that are defined in the geodatabase

Remark: IAttributeRule.Validate() is used to check the rows.

classmethod qa_gdb_constraint_factory(table: BaseDataset, allow_null_values_for_coded_value_domains: bool = True, allow_null_values_for_range_domains: bool = True, fields: Optional[List[str]] = None) → Condition

Finds all rows in ‘table’ that do not fulfill the attribute rules that are defined in the geodatabase

classmethod qa_gdb_release_0(table: BaseDataset, expected_version: str) → Condition

Verifies that the geodatabase release for a given table corresponds to a specified version.

classmethod qa_gdb_release_1(table: BaseDataset, minimum_version: str, maximum_version: str) → Condition

Verifies that the geodatabase release for a given table corresponds to a specified version range. The version range may be open on one side, by specifying only one of minimumVersion and maximumVersion.

classmethod qa_gdb_topology_1(feature_classes: List[BaseDataset]) → Condition

Finds all geodatabase topology errors in the topologies referenced by ‘featureClasses’.

Remark: If a topology has not been previously validated, the dirty areas are reported as issues. The reported issues are copies of the error features of the topology’s error features.

classmethod qa_geometry_constraint_0(feature_class: BaseDataset, geometry_constraint: str, per_part: bool) → Condition

Finds all features in ‘featureClass’ whose geometry (or geometry parts) do not fulfill ‘geometryConstraint’

classmethod qa_group_connected_0(polyline_class: BaseDataset, group_by: List[str], allowed_shape: ShapeAllowed, report_individual_gaps: bool = False, ignore_gaps_longer_than: float = -1, complete_groups_outside_test_area: bool = False) → Condition

Find errors in checking if polylines of ‘polylineClass’ with same attributes are connected. Reports disjoint line groups with ErrorReporting.ReferToFirstPart.

classmethod qa_group_connected_1(polyline_classes: List[BaseDataset], group_by: List[str], value_separator: str, allowed_shape: ShapeAllowed, error_reporting: GroupErrorReporting, minimum_error_connection_line_length: float, report_individual_gaps: bool = False, ignore_gaps_longer_than: float = -1, complete_groups_outside_test_area: bool = False) → Condition

Find errors in checking if polylines of ‘polylineClasses’ with same attributes are connected

classmethod qa_group_constraints_0(table: BaseDataset, group_by_expression: str, distinct_expression: str, max_distinct_count: int, limit_to_tested_rows: bool, exists_row_group_filters: Optional[List[str]] = None) → Condition

Checks if the number of distinct values of an expression (which may be a single field or a more complex expression involving field concatenation, value translation, substring extraction etc.) within groups defined by a ‘group by’ expression (which also may be a single field or a more complex expression on fields) does not exceed an allowed maximum value.

classmethod qa_group_constraints_1(tables: List[BaseDataset], group_by_expressions: List[str], distinct_expressions: List[str], max_distinct_count: int, limit_to_tested_rows: bool, exists_row_group_filters: Optional[List[str]] = None) → Condition

Checks if the number of distinct values of an expression (which may be a single field or a more complex expression involving field concatenation, value translation, substring extraction etc.) within groups defined by a ‘group by’ expression (which also may be a single field or a more complex expression on fields) does not exceed an allowed maximum value.

Example: Table A with Field ‘KeyA’ with a row KeyA = 5 Table B with Field ‘KeyB’ with a row KeyB = 5

Test with QaGroupConstraint({A,B}, {KeyA,KeyB}, {‘name A’, ‘name B’}, 1, false).

The row of table A and the row of table B belong to the same group, 5, evaluated by the corresponding groupByExpressions. In this group there are 2 distinct values, ‘name A’ from the row in table A and ‘name B’ from the row in table B. So the group 5 will be reported as error, because only 1 distinct value (see maxDistinctCount) is allowed.

classmethod qa_group_constraints_2(tables: List[BaseDataset], group_by_expressions: List[str], distinct_expressions: List[str], min_distinct_count: int, max_distinct_count: int, limit_to_tested_rows: bool, exists_row_group_filters: Optional[List[str]] = None) → Condition

Checks if the number of distinct values of an expression (which may be a single field or a more complex expression involving field concatenation, value translation, substring extraction etc.) within groups defined by a ‘group by’ expression (which also may be a single field or a more complex expression on fields) does not exceed an allowed maximum value.

Example: Table A with Field ‘KeyA’ with a row KeyA = 5 Table B with Field ‘KeyB’ with a row KeyB = 5

Test with QaGroupConstraint({A,B}, {KeyA,KeyB}, {‘name A’, ‘name B’}, 1, false).

The row of table A and the row of table B belong to the same group, 5, evaluated by the corresponding groupByExpressions. In this group there are 2 distinct values, ‘name A’ from the row in table A and ‘name B’ from the row in table B. So the group 5 will be reported as error, because only 1 distinct value (see maxDistinctCount) is allowed.

classmethod qa_horizontal_segments_0(feature_class: BaseDataset, limit: float, tolerance: float) → Condition

Finds almost horizontal segments: Find segments with a slope angle smaller than ‘limit’, but larger than ‘tolerance’.

classmethod qa_interior_intersects_other_0(feature_class: BaseDataset, related_class: BaseDataset, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds features in ‘relatedClass’ that have an interior intersection with a feature in ‘featureClass’

classmethod qa_interior_intersects_other_1(feature_class: BaseDataset, related_class: BaseDataset, constraint: str, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds pairs of features in ‘featureClass’ vs. ‘relatedClass’ that have an interior intersection, and for which a given constraint is not fulfilled.

classmethod qa_interior_intersects_other_2(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds pairs of features in ‘featureClasses’ vs. ‘relatedClasses’ that have an interior intersection.

classmethod qa_interior_intersects_other_3(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], constraint: str, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds pairs of features in ‘featureClasses’ vs. ‘relatedClasses’ that have an interior intersection, and for which a given constraint is not fulfilled.

classmethod qa_interior_intersects_self_0(feature_class: BaseDataset, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all pairs of features in a feature class with intersecting interiors.

classmethod qa_interior_intersects_self_1(feature_class: BaseDataset, constraint: str, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all pairs of features in a feature class with intersecting interiors, and for which a given constraint is not fulfilled.

classmethod qa_interior_intersects_self_2(feature_classes: List[BaseDataset], valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all pairs of features in a list of feature classes with intersecting interiors.

classmethod qa_interior_intersects_self_3(feature_classes: List[BaseDataset], constraint: str, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all pairs of features in a list of feature classes with intersecting interiors, and for which a given constraint is not fulfilled.

classmethod qa_interior_intersects_self_4(feature_classes: List[BaseDataset], constraint: str, report_intersections_as_multipart: bool, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all pairs of features in a list of feature classes with intersecting interiors, and for which a given constraint is not fulfilled. Optionally, all intersections between two features can be reported as one error with multipart error geometry.

classmethod qa_interior_rings_0(polygon_class: BaseDataset, maximum_interior_ring_count: int, ignore_inner_rings_larger_than: float = -1, report_individual_rings: bool = False, report_only_smallest_rings_exceeding_maximum_count: bool = True) → Condition

Finds interior rings of polygon features that exceed a given maximum ring count. Optionally, only inner rings that are smaller than a specified area are reported.

classmethod qa_intersection_matrix_other_0(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], intersection_matrix: str) → Condition

Finds all features in ‘featureClasses’ that have a given spatial relationship with features in ‘relatedClasses’. The spatial relationship of the error cases is defined by a 9IM intersection matrix.

Remark: All feature classes in ‘featureClasses’ and ‘relatedClasses’ must have the same spatial reference.

classmethod qa_intersection_matrix_other_1(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], intersection_matrix: str, constraint: str) → Condition

Finds all features in ‘featureClasses’ that have a given spatial relationship with features in ‘relatedClasses’, and for which a given constraint is not fulfilled. The spatial relationship of the error cases is defined by a 9IM intersection matrix.

Remark: All feature classes in ‘featureClasses’ and ‘relatedClasses’ must have the same spatial reference.

classmethod qa_intersection_matrix_other_2(feature_class: BaseDataset, related_class: BaseDataset, intersection_matrix: str) → Condition

Finds all features in ‘featureClass’ that have a given spatial relationship with features in ‘relatedClass’. The spatial relationship of the error cases is defined by a 9IM intersection matrix.

Remark: The feature classes in ‘featureClass’ and ‘relatedClass’ must have the same spatial reference.

classmethod qa_intersection_matrix_other_3(feature_class: BaseDataset, related_class: BaseDataset, intersection_matrix: str, constraint: str) → Condition

Finds all features in ‘featureClass’ that have a given spatial relationship with features in ‘relatedClass’, and for which a given constraint is not fulfilled. The spatial relationship of the error cases is defined by a 9IM intersection matrix.

Remark: The feature classes in ‘featureClass’ and ‘relatedClass’ must have the same spatial reference.

classmethod qa_intersection_matrix_other_4(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], intersection_matrix: str, constraint: str, valid_intersection_dimensions: str) → Condition

Finds all features in ‘featureClass’ that have a given spatial relationship with features in ‘relatedClass’, and for which a given constraint is not fulfilled. The spatial relationship of the error cases is defined by a 9IM intersection matrix. A list of valid intersection dimensions can be specified. Any parts of the intersection geometry (according to the 9IM intersection matrix) with a dimension that is included in this list are not reported as errors.

Remark: The feature classes in ‘featureClass’ and ‘relatedClass’ must have the same spatial reference.

classmethod qa_intersection_matrix_self_0(feature_classes: List[BaseDataset], intersection_matrix: str) → Condition

Finds all features in ‘featureClasses’ that have a given spatial relationship with other features in ‘featureClasses’ (including the feature class of the feature to be tested). The spatial relationship of the error cases is defined by a 9IM intersection matrix.

Remark: The feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_intersection_matrix_self_1(feature_classes: List[BaseDataset], intersection_matrix: str, constraint: str) → Condition

Finds all features in ‘featureClasses’ that have a given spatial relationship with other features in ‘featureClasses’ (including the feature class of the feature to be tested), and for which a given constraint is not fulfilled. The spatial relationship of the error cases is defined by a 9IM intersection matrix.

Remark: The feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_intersection_matrix_self_2(feature_class: BaseDataset, intersection_matrix: str) → Condition

Finds all features in ‘featureClass’ that have a given spatial relationship with other features in ‘featureClass’. The spatial relationship of the error cases is defined by a 9IM intersection matrix.

classmethod qa_intersection_matrix_self_3(feature_class: BaseDataset, intersection_matrix: str, constraint: str) → Condition

Finds all features in ‘featureClass’ that have a given spatial relationship with other features in ‘featureClass’, and for which a given constraint is not fulfilled. The spatial relationship of the error cases is defined by a 9IM intersection matrix.

classmethod qa_intersection_matrix_self_4(feature_classes: List[BaseDataset], intersection_matrix: str, constraint: str, valid_intersection_dimensions: str) → Condition

Finds all features in ‘featureClass’ that have a given spatial relationship with other features in ‘featureClass’, and for which a given constraint is not fulfilled. The spatial relationship of the error cases is defined by a 9IM intersection matrix. A list of valid intersection dimensions can be specified. Any parts of the intersection geometry (according to the 9IM intersection matrix) with a dimension that is included in this list are not reported as errors.

classmethod qa_intersects_other_0(intersected: List[BaseDataset], intersecting: List[BaseDataset], report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘intersectingClasses’ that intersect by any features of ‘intersectedClasses’

Remark: All feature classes in ‘intersectedClasses’ and ‘intersectingClasses’ must have the same spatial reference.

classmethod qa_intersects_other_1(intersected: BaseDataset, intersecting: BaseDataset, report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘intersectingClass’ that intersect by any features of ‘intersectedClass’

Remark: The feature classes in ‘intersectedClass’ and ‘intersectingClass’ must have the same spatial reference.

classmethod qa_intersects_other_2(intersected_classes: List[BaseDataset], intersecting_classes: List[BaseDataset], valid_relation_constraint: str, report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘intersectingClasses’ that intersect by any features of ‘intersectedClasses’, and for which a given constraint is not fulfilled.

Remark: All feature classes in ‘intersectedClasses’ and ‘intersectingClasses’ must have the same spatial reference.

classmethod qa_intersects_other_3(intersected_class: BaseDataset, intersecting_class: BaseDataset, valid_relation_constraint: str, report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘intersectingClass’ that intersect by any features of ‘intersectedClass’, and for which a given constraint is not fulfilled.

Remark: The feature classes in ‘intersectedClass’ and ‘intersectingClass’ must have the same spatial reference.

classmethod qa_intersects_self_0(feature_class: BaseDataset, report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None, geometry_components: List[GeometryComponent] = 0) → Condition

Finds all features in ‘featureClass’ that intersect any feature in ‘featureClass’

classmethod qa_intersects_self_1(feature_classes: List[BaseDataset], report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None, geometry_components: List[GeometryComponent] = 0) → Condition

Finds all features in ‘featureClasses’ that intersect any feature in ‘featureClasses’

classmethod qa_intersects_self_2(feature_classes: List[BaseDataset], valid_relation_constraint: str, report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None, geometry_components: List[GeometryComponent] = 0) → Condition

Finds all features in ‘featureClasses’ that intersect any feature in ‘featureClasses’, and for which a given constraint is not fulfilled.

classmethod qa_intersects_self_3(feature_class: BaseDataset, valid_relation_constraint: str, report_intersections_as_multipart: bool = True, valid_intersection_geometry_constraint: Optional[str] = None, geometry_components: List[GeometryComponent] = 0) → Condition

Finds all features in ‘featureClass’ that intersect any feature in ‘featureClass’, and for which a given constraint is not fulfilled.

classmethod qa_is_covered_by_other_0(covering: List[BaseDataset], covered: List[BaseDataset], covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ that are not fully covered by the features in ‘covering’

Remarks: All feature classes in ‘covered’ and ‘covering’ must have the same spatial reference.

classmethod qa_is_covered_by_other_1(covering: BaseDataset, covered: BaseDataset, covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ that are not fully covered by the features in ‘covering’

Remarks: The feature classes in ‘covered’ and ‘covering’ must have the same spatial reference.

classmethod qa_is_covered_by_other_2(covering: List[BaseDataset], covered: List[BaseDataset], is_covering_condition: str, covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ that are not fully covered by the features in ‘covering’ for which a given condition is fulfilled

Remarks: All feature classes in ‘covered’ and ‘covering’ must have the same spatial reference.

classmethod qa_is_covered_by_other_3(covering: BaseDataset, covered: BaseDataset, is_covering_condition: str, covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ that are not fully covered by the features in ‘covering’ for which a given condition is fulfilled

Remarks: All feature classes in ‘covered’ and ‘covering’ must have the same spatial reference.

classmethod qa_is_covered_by_other_4(covering: List[BaseDataset], covering_geometry_components: List[GeometryComponent], covered: List[BaseDataset], covered_geometry_components: List[GeometryComponent], is_covering_condition: str, covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ for which the specified geometry components are not fully covered by the specified geometry component of features in ‘covering’.

The following geometry components are supported:

• EntireGeometry: the original feature geometry

• Boundary: supported for polygons and polylines. For polylines, the boundary consists of the start/end points of all parts. For polygons, it corresponds to the outlines of all polygon rings.

• Vertices: supported for polygons, polylines, multipatches and multiparts. The vertices of the geometry.

• LineEndPoints: supported for polylines. The start and end point of the entire polyline, i.e. the start point of the first path and the end point of the last path.

• LineStartPoint: supported for polylines. The start point of the entire polyline, i.e. the start point of the first path.

• LineEndPoint: supported for polylines. The end point of the entire polyline, i.e. the end point of the last path.

• Centroid: supported for polygons. The centroid point of the entire polygon.

• LabelPoint: supported for polygons. The label point of the entire polygon.

• InteriorVertices: supported for polylines. All line vertices except the start and end point of the entire polyline.

The number of geometry components in the list must be either 0 (in which case ‘EntireGeometry’ is used as default), 1 (in which case that component is used for all feature classes in the list) or equal to the number of feature classes. In that case, the components are assigned to the feature classes by their index position in the list.

classmethod qa_is_covered_by_other_5(covering: List[BaseDataset], covering_geometry_components: List[GeometryComponent], covered: List[BaseDataset], covered_geometry_components: List[GeometryComponent], is_covering_condition: str, allowed_uncovered_percentage: float, covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ for which the specified geometry components are not sufficiently covered by the specified geometry component of features in ‘covering’. An allowed uncovered percentage may be specified.

The following geometry components are supported:

• EntireGeometry: the original feature geometry

• Boundary: supported for polygons and polylines. For polylines, the boundary consists of the start/end points of all parts. For polygons, it corresponds to the outlines of all polygon rings.

• Vertices: supported for polygons, polylines, multipatches and multiparts. The vertices of the geometry.

• LineEndPoints: supported for polylines. The start and end point of the entire polyline, i.e. the start point of the first path and the end point of the last path.

• LineStartPoint: supported for polylines. The start point of the entire polyline, i.e. the start point of the first path.

• LineEndPoint: supported for polylines. The end point of the entire polyline, i.e. the end point of the last path.

• Centroid: supported for polygons. The centroid point of the entire polygon.

• LabelPoint: supported for polygons. The label point of the entire polygon.

• InteriorVertices: supported for polylines. All line vertices except the start and end point of the entire polyline.

The number of geometry components in the list must be either 0 (in which case ‘EntireGeometry’ is used as default), 1 (in which case that component is used for all feature classes in the list) or equal to the number of feature classes. In that case, the components are assigned to the feature classes by their index position in the list.

classmethod qa_is_covered_by_other_6(covering: List[BaseDataset], covering_geometry_components: List[GeometryComponent], covered: List[BaseDataset], covered_geometry_components: List[GeometryComponent], is_covering_conditions: List[str], allowed_uncovered_percentage: float, covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ for which the specified geometry components are not sufficiently covered by the specified geometry component of features in ‘covering’. An allowed uncovered percentage may be specified.

The following geometry components are supported:

• EntireGeometry: the original feature geometry

• Boundary: supported for polygons and polylines. For polylines, the boundary consists of the start/end points of all parts. For polygons, it corresponds to the outlines of all polygon rings.

• Vertices: supported for polygons, polylines, multipatches and multiparts. The vertices of the geometry.

• LineEndPoints: supported for polylines. The start and end point of the entire polyline, i.e. the start point of the first path and the end point of the last path.

• LineStartPoint: supported for polylines. The start point of the entire polyline, i.e. the start point of the first path.

• LineEndPoint: supported for polylines. The end point of the entire polyline, i.e. the end point of the last path.

• Centroid: supported for polygons. The centroid point of the entire polygon.

• LabelPoint: supported for polygons. The label point of the entire polygon.

• InteriorVertices: supported for polylines. All line vertices except the start and end point of the entire polyline.

The number of geometry components in the list must be either 0 (in which case ‘EntireGeometry’ is used as default), 1 (in which case that component is used for all feature classes in the list) or equal to the number of feature classes. In that case, the components are assigned to the feature classes by their index position in the list.

classmethod qa_is_covered_by_other_7(covering: List[BaseDataset], covering_geometry_components: List[GeometryComponent], covered: List[BaseDataset], covered_geometry_components: List[GeometryComponent], is_covering_conditions: List[str], allowed_uncovered_percentage: float, area_of_interest_classes: List[BaseDataset], covering_class_tolerances: List[float] = 0, valid_uncovered_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘covered’ for which the specified geometry components are not sufficiently covered by the specified geometry component of features in ‘covering’, within an (optional) area of interest defined by polygons from ‘areaOfInterestClasses’. An allowed uncovered percentage may be specified.

The following geometry components are supported:

• EntireGeometry: the original feature geometry

• Boundary: supported for polygons and polylines. For polylines, the boundary consists of the start/end points of all parts. For polygons, it corresponds to the outlines of all polygon rings.

• Vertices: supported for polygons, polylines, multipatches and multiparts. The vertices of the geometry.

• LineEndPoints: supported for polylines. The start and end point of the entire polyline, i.e. the start point of the first path and the end point of the last path.

• LineStartPoint: supported for polylines. The start point of the entire polyline, i.e. the start point of the first path.

• LineEndPoint: supported for polylines. The end point of the entire polyline, i.e. the end point of the last path.

The number of geometry components in the list must be either 0 (in which case ‘EntireGeometry’ is used as default), 1 (in which case that component is used for all feature classes in the list) or equal to the number of feature classes. In that case, the components are assigned to the feature classes by their index position in the list.

classmethod qa_line_connection(feature_classes: List[BaseDataset], rules: List[str]) → Condition

Finds all connected features in ‘featureClasses’ that do not correspond with the ‘rules’. ‘featureClasses’ can consist of line and point featureclasses. ‘rules’ are checked at all distinct points that exist as start/endpoint (line featureclasses) or points (point featureclasses). Remark: the feature classes in ‘featureClasses’ must have the same spatial reference. The rules are processed in ordered direction. If the involved features correspond to no rule, they are reported.

One rule consists out of one expression for each featureClass. Each expression is either null or has a selection expression. Additionally, a expression can have variable declarations separated by “;”. Optionally, one expression of a rule can have count condition (separeted by “;”), where the declared variables can be checked.

A selection expression is a constraint on the corresponding featureclass (Example: “ObjektArt IN (x,y)”). If any feature connected at a point does not fulfill the selection expression for the corresponding featureclass, the corresponding rule is considered invalid and the next rules are checked for validity.

A variable expression is formatted “<variablename>:<count expression>” (Example: “v1:Objektart=r”). The value of the variable is equal the count of the features at a point that fulfill the <count expression> (for the corresponding feature Class). For polyline featureclasses, an additional attribute “_StartsIn” is available in the count expression. The attribute value is true, if the FromPoint of the polyline lies at the point, and false, if the ToPoint lies at the point. Remark: If the FromPoint and ToPoint of a polyline are coincident, the polyline corresponds to two features in that point, one with _StartsIn=true and one with _StartsIn=false.

A count expression checks if the variables fulfill a condition (Example: “v1 =1 AND v2=1”, where v1, v2 are declared variables). If the count expression is false, the corresponding rule is considered invalid and the next rules are checked for validity. A count expression can /should use all variables declared in any expression of the corresponding rule. If a variable is not use in the count expression, the variable can be ommitted.

Example: featureClasses: A, B rules: {

{ “ObjektArt IN (x,y)”, “ObjektArt IN (u,v)” },

// Meaning: all involved features belong either to A with ObjektArt in (x,y) or to B with ObjektArt in (u,v)

{ “ObjektArt = z”, null },

// Meaning: No B-Feature must touch any A-Feature with ObjektArt = z

{ null, “ObjektArt = t” },

// Meaning: no A-Feature must touch any B-Feature with ObjektArt = t

{ “true;v1:ObjektArt=r;v2:Objektart=s;”, “ObjektArt in (u,v);v1 =1 AND v2=1” }

// Meaning: all feature of A and the features of B in (u,v) can be involved. Additionally, the count of A.ObjektArt =r must be 1 and the count of A.ObjektArt=s must be 1

}

classmethod qa_line_connection_field_values_0(line_class: BaseDataset, line_field: str, line_field_values_constraint: LineFieldValuesConstraint, point_class: BaseDataset, point_field: str, point_field_values_constraint: PointFieldValuesConstraint) → Condition

Checks constraints for the distinct values of fields from connected line and point features at a location.

classmethod qa_line_connection_field_values_1(line_classes: List[BaseDataset], line_fields: List[str], line_field_values_constraint: LineFieldValuesConstraint, point_class: BaseDataset, point_field: str, point_field_values_constraint: PointFieldValuesConstraint) → Condition

Checks constraints for the distinct values of fields from connected line and point features at a location.

classmethod qa_line_connection_field_values_2(line_class: BaseDataset, line_field: str, line_field_values_constraint: LineFieldValuesConstraint, point_class: BaseDataset) → Condition

Checks constraints for the distinct values of fields from connected lines at a location.

classmethod qa_line_connection_field_values_3(line_classes: List[BaseDataset], line_fields: List[str], line_field_values_constraint: LineFieldValuesConstraint, point_class: BaseDataset, point_field: str, point_field_values_constraint: PointFieldValuesConstraint, allowed_points_expression: str) → Condition

Checks constraints for the distinct values of fields from connected lines at a location.

classmethod qa_line_connection_field_values_4(line_classes: List[BaseDataset], line_fields: List[str], line_field_values_constraint: LineFieldValuesConstraint, point_classes: List[BaseDataset], point_fields: List[str], point_field_values_constraint: PointFieldValuesConstraint, allowed_points_expressions: List[str]) → Condition

Checks constraints for the distinct values of fields from connected lines at a location.

classmethod qa_line_group_constraints_0(network_feature_classes: List[BaseDataset], min_gap: float, min_group_length: float, min_dangle_length: float, group_by: List[str], value_separator: Optional[str] = None, group_conditions: Optional[List[str]] = None, min_gap_to_other_group_type: float = 0, min_dangle_length_continued: float = 0, min_dangle_length_at_fork_continued: float = 0, min_dangle_length_at_fork: float = 0, min_gap_to_same_group_type_covered: float = 0, min_gap_to_same_group_type_at_fork: float = 0, min_gap_to_same_group_type_at_fork_covered: float = 0, min_gap_to_other_group_type_at_fork: float = 0, min_gap_to_same_group: float = 0) → Condition

Find errors in checking if connected polylines of ‘networkFeatureClasses’ with same attributes related to ‘groupBy’ meet the conditions defined by the parameters

classmethod qa_line_intersect_0(polyline_classes: List[BaseDataset], allowed_interior_intersections: AllowedLineInteriorIntersections = 0) → Condition

Finds all features in ‘polylineClasses’ that cross any other feature in ‘polylineClasses’

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_line_intersect_1(polyline_class: BaseDataset, allowed_interior_intersections: AllowedLineInteriorIntersections = 0) → Condition

Finds all features in ‘polylineClass’ that cross any other feature in ‘polylineClass’

classmethod qa_line_intersect_2(polyline_classes: List[BaseDataset], valid_relation_constraint: str, allowed_interior_intersections: AllowedLineInteriorIntersections = 0) → Condition

Finds all features in ‘polylineClasses’ that cross any other feature in ‘polylineClasses’, and for which a given constraint is not fulfilled.

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_line_intersect_3(polyline_class: BaseDataset, valid_relation_constraint: str, allowed_interior_intersections: AllowedLineInteriorIntersections = 0) → Condition

Finds all features in ‘polylineClass’ that cross any other feature in ‘polylineClass’, and for which a given constraint is not fulfilled.

classmethod qa_line_intersect_4(polyline_classes: List[BaseDataset], valid_relation_constraint: str, allowed_endpoint_interior_intersections: AllowedEndpointInteriorIntersections, report_overlaps: bool, allowed_interior_intersections: AllowedLineInteriorIntersections = 0) → Condition

Finds all features in ‘polylineClasses’ that have invalid point intersections with any other feature in ‘polylineClasses’, and for which a given constraint is not fulfilled. Invalid point intersections are points where lines cross, and where end points of one line have an unallowed intersection with the interior of the other line. Optionally, linear intersections are also reported (based on the Overlaps relation between the line geometries). Without this option, only point intersections are reported.

classmethod qa_line_intersect_angle_0(polyline_classes: List[BaseDataset], limit: float, is3d: bool, angular_unit: AngleUnit = 0) → Condition

Finds all intersection between lines of ‘polylineClasses’ where the intersection angle is smaller than ‘limit’

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_line_intersect_angle_2(polyline_classes: List[BaseDataset], limit: float, angular_unit: AngleUnit = 0) → Condition

Finds all intersection between lines of ‘polylineClasses’ where the intersection angle is smaller than ‘limit’

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_line_intersect_angle_3(polyline_class: BaseDataset, limit: float, angular_unit: AngleUnit = 0) → Condition

Finds all intersection between lines of ‘polylineClasses’ where the intersection angle is smaller than ‘limit’

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_line_intersect_z_0(polyline_classes: List[BaseDataset], limit: float, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds intersections of features in ‘polylineClasses’ where the height difference is smaller than ‘limit’

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_line_intersect_z_1(polyline_class: BaseDataset, limit: float, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds intersections of features in ‘polylineClass’ where the height difference is smaller than ‘limit’

classmethod qa_line_intersect_z_2(polyline_class: BaseDataset, limit: float, constraint: str, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds intersections of features in ‘polylineClass’ where the height difference is smaller than ‘limit’ and ‘constraint’ is not fulfilled

classmethod qa_line_intersect_z_3(polyline_classes: List[BaseDataset], limit: float, constraint: str, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds intersections of features in ‘polylineClasses’ where the height difference is smaller than ‘limit’ and ‘constraint’ is not fulfilled

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_line_intersect_z_4(polyline_classes: List[BaseDataset], minimum_z_difference: float, maximum_z_difference: float, constraint: str, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds intersections of features in ‘polylineClasses’ where the height difference is smaller than ‘minimum’ or larger than ‘maximum’ or ‘constraint’ is not fulfilled

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_max_area_0(polygon_class: BaseDataset, limit: float) → Condition

Finds all polygons in ‘polygonClass’ with areas larger than ‘limit’

classmethod qa_max_area_1(polygon_class: BaseDataset, limit: float, per_part: bool) → Condition

Finds all parts in ‘polygonClass’ with areas larger than ‘limit’. Parts are defined by perPart

classmethod qa_max_length_0(feature_class: BaseDataset, limit: float, is3_d: bool) → Condition

Finds all lines in ‘featureClass’ with length larger than ‘limit’

classmethod qa_max_length_1(feature_class: BaseDataset, limit: float) → Condition

Finds all lines in ‘featureClass’ with length larger than ‘limit’

classmethod qa_max_length_2(feature_class: BaseDataset, limit: float, is3_d: bool, per_part: bool) → Condition

Finds all lines in ‘featureClass’ with length larger than ‘limit’

classmethod qa_max_slope_0(feature_class: BaseDataset, limit: float, angular_unit: AngleUnit = 0) → Condition

Finds all segments in ‘featureClass’ where the slope is larger than ‘limit’

classmethod qa_max_vertex_count_0(feature_class: BaseDataset, limit: float, per_part: bool) → Condition

Finds polygon/polyline/multipoint features or feature parts with a vertex count larger than ‘limit’

classmethod qa_measures_0(feature_class: BaseDataset) → Condition

Finds vertices or segments with undefined (NaN) M values.

classmethod qa_measures_1(feature_class: BaseDataset, invalid_value: float) → Condition

Finds vertices or segments with an invalid M value.

classmethod qa_measures_at_points_0(point_class: BaseDataset, expected_m_value_expression: str, line_classes: List[BaseDataset], search_distance: float, m_tolerance: float, line_m_source: LineMSource, require_line: bool) → Condition

Finds points on ‘lineClasses’ whose m-Values differ from the neighboring ‘pointClass’-point

Remark: All feature classes in ‘pointClass’ and ‘lineClasses’ must have the same spatial reference.

classmethod qa_measures_at_points_1(point_class: BaseDataset, expected_m_value_expression: str, line_classes: List[BaseDataset], search_distance: float, m_tolerance: float, line_m_source: LineMSource, require_line: bool, ignore_undefined_expected_m_value: bool, match_expression: str) → Condition

Finds points on ‘lineClasses’ whose m-Values differ from the neighboring ‘pointClass’-point

Remark: All feature classes in ‘pointClass’ and ‘lineClasses’ must have the same spatial reference.

classmethod qa_min_angle_0(polyline_class: BaseDataset, limit: float, is3_d: bool, angular_unit: AngleUnit = 0) → Condition

Finds all pair of (From/To-) points in ‘polylineClass’ where the angle built by the lines is smaller than ‘limit’

classmethod qa_min_angle_1(polyline_classes: List[BaseDataset], limit: float, is3_d: bool, angular_unit: AngleUnit = 0) → Condition

Finds all pair of (From/To-) points in ‘polylineClasses’ where the angle built by the lines is smaller than ‘limit’

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_min_angle_2(polyline_classes: List[BaseDataset], limit: float, angular_unit: AngleUnit = 0) → Condition

Finds all pair of (From/To-) points in ‘polylineClasses’ where the angle built by the lines is smaller than ‘limit’

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_min_area_0(polygon_class: BaseDataset, limit: float) → Condition

Finds all polygons in ‘polygonClass’ with areas smaller than ‘limit’. Features with empty geometries are not tested.

classmethod qa_min_area_1(polygon_class: BaseDataset, limit: float, per_part: bool) → Condition

Finds all parts in ‘polygonClass’ with areas smaller than ‘limit’. Parts are defined by perPart. Features with empty geometries are not tested.

classmethod qa_min_intersect_0(polygon_classes: List[BaseDataset], limit: float) → Condition

Finds all area overlaps between two features in ‘polygonClasses’, where the overlapping area is smaller than ‘limit’

Remark: The feature classes in ‘polygonClasses’ must have the same spatial reference.

classmethod qa_min_intersect_1(polygon_class: BaseDataset, limit: float) → Condition

Finds all area overlaps between two features in ‘polygonClass’, where the overlapping area is smaller than ‘limit’

classmethod qa_min_length_0(feature_class: BaseDataset, limit: float, is3_d: bool) → Condition

Finds all lines in ‘featureClass’ with length smaller than ‘limit’

classmethod qa_min_length_1(feature_class: BaseDataset, limit: float) → Condition

Finds all lines in ‘featureClass’ with length smaller than ‘limit’

classmethod qa_min_length_2(feature_class: BaseDataset, limit: float, is3_d: bool, per_part: bool) → Condition

Finds all lines in ‘featureClass’ with length smaller than ‘limit’

classmethod qa_min_mean_segment_length_0(feature_class: BaseDataset, limit: float, per_part: bool) → Condition

Finds polygon/polyline features or feature parts with an average segment length smaller than ‘limit’

classmethod qa_min_mean_segment_length_1(feature_class: BaseDataset, limit: float, per_part: bool, is3_d: bool) → Condition

Finds polygon/polyline features or feature parts with an average segment length smaller than ‘limit’

classmethod qa_min_node_distance_0(feature_class: BaseDataset, near: float, is3_d: bool) → Condition

Finds all pair of (From/To-) points of ‘featureClass’ closer than ‘near’

classmethod qa_min_node_distance_1(feature_classes: List[BaseDataset], near: float, is3_d: bool) → Condition

Finds all pair of (From/To-) points of ‘featureClasses’ closer than ‘near’

Remark: The feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_min_node_distance_10(feature_classes: List[BaseDataset], near: float, tolerance: float, max_z_difference: float, valid_relation_constraint: str) → Condition

Finds all pair of (From/To-) points of ‘featureClasses’ closer than ‘near’ and find all coincident pairs with z-coordinate difference larger than ‘maxZDifference’. Pairs closer than ‘tolerance’ are considered coincident. No error is reported for point pairs that fulfill a defined constraint.

classmethod qa_min_node_distance_11(feature_class: BaseDataset, near: float, tolerance: float, is3_d: bool, valid_relation_constraint: str) → Condition

Finds all pair of (From/To-) points of ‘featureClass’ closer than ‘near’. Pairs closer than ‘tolerance’ are considered coincident. No error is reported for point pairs that fulfill a defined constraint.

classmethod qa_min_node_distance_12(feature_classes: List[BaseDataset], near: float, tolerance: float, is3_d: bool, valid_relation_constraint: str) → Condition

Finds all pair of (From/To-) points of ‘featureClasses’ closer than ‘near’. Pairs closer than ‘tolerance’ are considered coincident. No error is reported for point pairs that fulfill a defined constraint.

Remark: The feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_min_node_distance_2(feature_class: BaseDataset, near: float, tolerance: float, is3_d: bool) → Condition

Finds all pair of (From/To-) points of ‘featureClass’ closer than ‘near’. Pairs closer than ‘tolerance’ are considered coincident

classmethod qa_min_node_distance_3(feature_classes: List[BaseDataset], near: float, tolerance: float, is3_d: bool) → Condition

Finds all pair of (From/To-) points of ‘featureClasses’ closer than ‘near’. Pairs closer than ‘tolerance’ are considered coincident

Remark: The feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_min_node_distance_4(feature_class: BaseDataset, near: float, max_z_difference: float) → Condition

Finds all pair of (From/To-) points of ‘featureClass’ closer than ‘near’ and find all coincident pairs with z-coordinate difference larger than ‘maxZDifference’

classmethod qa_min_node_distance_5(feature_classes: List[BaseDataset], near: float, max_z_difference: float) → Condition

Finds all pair of (From/To-) points of ‘featureClasses’ closer than ‘near’ and find all coincident pairs with z-coordinate difference larger than ‘maxZDifference’

Remark: The feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_min_node_distance_6(feature_class: BaseDataset, near: float, tolerance: float, max_z_difference: float) → Condition

Finds all pair of (From/To-) points of ‘featureClass’ closer than ‘near’ and find all coincident pairs with z-coordinate difference larger than ‘maxZDifference’. Pairs closer than ‘tolerance’ are considered coincident

classmethod qa_min_node_distance_7(feature_classes: List[BaseDataset], near: float, tolerance: float, max_z_difference: float) → Condition

Finds all pair of (From/To-) points of ‘featureClasses’ closer than ‘near’ and find all coincident pairs with z-coordinate difference larger than ‘maxZDifference’. Pairs closer than ‘tolerance’ are considered coincident

classmethod qa_min_node_distance_8(feature_classes: List[BaseDataset], near: float) → Condition

Finds all pair of (From/To-) points of ‘featureClasses’ closer than ‘near’

Remark: The feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_min_node_distance_9(feature_class: BaseDataset, near: float, tolerance: float, max_z_difference: float, valid_relation_constraint: str) → Condition

Finds all pair of (From/To-) points of ‘featureClass’ closer than ‘near’ and find all coincident pairs with z-coordinate difference larger than ‘maxZDifference’. Pairs closer than ‘tolerance’ are considered coincident. No error is reported for point pairs that fulfill a defined constraint.

classmethod qa_min_seg_angle_0(feature_class: BaseDataset, limit: float, is3_d: bool, use_tangents: bool = False, angular_unit: AngleUnit = 0) → Condition

Finds all consecutive segments in ‘featureClass’ where the angle between two segments is smaller than ‘limit’

classmethod qa_min_seg_angle_1(feature_class: BaseDataset, limit: float, use_tangents: bool = False, angular_unit: AngleUnit = 0) → Condition

Finds all consecutive segments in ‘featureClass’ where the angle between two segments is smaller than ‘limit’

classmethod qa_monotonic_measures_0(line_class: BaseDataset, allow_constant_values: bool) → Condition

Finds non-monotonic sequences in M values

classmethod qa_monotonic_measures_1(line_class: BaseDataset, allow_constant_values: bool, expected_monotonicity: MonotonicityDirection, flip_expression: str) → Condition

Finds non-monotonic sequences in M values for a given direction

classmethod qa_monotonic_z_0(line_class: BaseDataset, allow_constant_values: bool = True, expected_monotonicity: MonotonicityDirection = 0, flip_expression: Optional[str] = None) → Condition

Finds non-monotonic sequences in Z values

classmethod qa_mp_allowed_part_types_0(multi_patch_class: BaseDataset, allow_rings: bool, allow_triangle_fans: bool, allow_triangle_strips: bool, allow_triangles: bool) → Condition

Finds all geometry parts of ‘multipatchClass’ that not allowed part types

classmethod qa_mp_constant_point_ids_per_ring_0(multi_patch_class: BaseDataset, include_inner_rings: bool) → Condition

Find rings where the pointIds of its points are not constant

classmethod qa_mp_footprint_holes_0(multi_patch_class: BaseDataset, inner_ring_handling: InnerRingHandling, horizontal_z_tolerance: float = 0, resolution_factor: float = 1, minimum_area: float = -1, report_vertical_patches_not_completely_within_footprint: bool = True) → Condition

Find multipatch features where footprints have inner rings

classmethod qa_mp_horizontal_azimuths_0(multi_patch_class: BaseDataset, near_angle: float, azimuth_tolerance: float, horizontal_tolerance: float, per_ring: bool) → Condition

Find all horizontal segments of a multipatch feature where their azimuth’s differ less than ‘nearAngle’ but more than ‘azimuthTolerance’

classmethod qa_mp_horizontal_heights_0(multi_patch_class: BaseDataset, near_height: float, height_tolerance: float) → Condition

Find all horizontal segment pairs of a multipatch feature where their heights differ less than ‘nearHeight’ but more than ‘heightTolerance’

classmethod qa_mp_horizontal_perpendicular_0(multi_patch_class: BaseDataset, near_angle: float, azimuth_tolerance: float, horizontal_tolerance: float, connected_only: bool, connected_tolerance: float) → Condition

Find all horizontal segment pairs of a multipatch feature where their azimuth’s differ less than ‘nearAngle’ from 90° but more than ‘azimuthTolerance’

classmethod qa_mp_non_intersecting_ring_footprints_0(multi_patch_class: BaseDataset, allow_intersections_for_different_point_ids: bool, resolution_factor: float = 1) → Condition

Finds multipatch features having rings whose 2D footprints have an interior intersection. Optionally, intersections of footprint interiors can be allowed for rings having different, unique point ids.

classmethod qa_mp_single_part_footprint_0(multi_patch_class: BaseDataset, resolution_factor: float = 100) → Condition

Finds multipatch features with a 2D footprint that consists of more than one disjoint part.

classmethod qa_mp_vertex_not_near_face_0(multi_patch_class: BaseDataset, vertex_classes: List[BaseDataset], minimum_distance_above: float, minimum_distance_below: float, coplanarity_tolerance: float = 0, report_non_coplanarity: bool = False, ignore_non_coplanar_faces: bool = False, verify_within_feature: bool = False, point_coincidence: float = 0, edge_coincidence: float = 0, plane_coincidence: float = -1, minimum_slope_degrees: float = 0) → Condition

Finds vertices of ‘vertexClasses’ that are not far enough above or below the faces of ‘multiPatchClass’

classmethod qa_mp_vertical_faces_0(multi_patch_class: BaseDataset, near_angle: float, tolerance_angle: float) → Condition

Finds patches in a multipatch that are almost vertical

classmethod qa_multipart_0(feature_class: BaseDataset) → Condition

Find all multipart features in ‘featureClass’

classmethod qa_multipart_1(feature_class: BaseDataset, single_ring: bool) → Condition

Find all multipart features in ‘featureClass’

classmethod qa_must_be_near_other_0(feature_class: BaseDataset, near_classes: List[BaseDataset], maximum_distance: float, relevant_relation_condition: str, error_distance_format: Optional[str] = None) → Condition

Finds all features in ‘featureClass’ that are not closer than ‘maximumDistance’ to any feature of ‘nearClasses’, or for which nearby features in ‘nearClasses’ do exist, but a given comparison constraint is not fulfilled. Note that errors can be reported only for features that are completely within the verified extent. Features that extend beyond the verified extent may have valid neighbors outside of the searched extent, and are therefore ignored.

classmethod qa_must_intersect_matrix_other_0(feature_class: BaseDataset, other_feature_class: BaseDataset, intersection_matrix: str, relevant_relation_condition: str) → Condition

Finds all features in ‘featureClass’ that do not have a given spatial relationship with any feature in ‘otherFeatureClass’, or for which a given constraint is not fulfilled. The required spatial relationship is defined by a 9IM intersection matrix.

Remark: The feature classes in ‘featureClass’ and ‘relatedClass’ must have the same spatial reference.

classmethod qa_must_intersect_matrix_other_1(feature_class: BaseDataset, other_feature_class: BaseDataset, intersection_matrix: str, relevant_relation_condition: str, required_intersection_dimensions: str, unallowed_intersection_dimensions: str) → Condition

Finds all features in ‘featureClass’ that do not have a given spatial relationship with any feature in ‘otherFeatureClass’, or for which a given constraint is not fulfilled. The required spatial relationship is defined by a 9IM intersection matrix. Optionally, the required and unallowed intersection dimensions may be defined.

Remark: The feature classes in ‘featureClass’ and ‘relatedClass’ must have the same spatial reference.

classmethod qa_must_intersect_matrix_other_2(feature_classes: List[BaseDataset], other_feature_classes: List[BaseDataset], intersection_matrix: str, relevant_relation_condition: str) → Condition

Finds all features in ‘featureClasses’ that do not have a given spatial relationship with any feature in ‘otherFeatureClasses’, or for which a given constraint is not fulfilled. The required spatial relationship is defined by a 9IM intersection matrix.

Remark: The feature classes in ‘featureClass’ and ‘relatedClass’ must have the same spatial reference.

classmethod qa_must_intersect_matrix_other_3(feature_classes: List[BaseDataset], other_feature_classes: List[BaseDataset], intersection_matrix: str, relevant_relation_condition: str, required_intersection_dimensions: str, unallowed_intersection_dimensions: str) → Condition

Finds all features in ‘featureClasses’ that do not have a given spatial relationship with any feature in ‘otherFeatureClasses’, or for which a given constraint is not fulfilled. The required spatial relationship is defined by a 9IM intersection matrix. Optionally, the required and unallowed intersection dimensions may be defined.

Remark: The feature classes in ‘featureClass’ and ‘relatedClass’ must have the same spatial reference.

classmethod qa_must_intersect_other_0(feature_class: BaseDataset, other_feature_class: BaseDataset, relevant_relation_condition: str) → Condition

Finds features that don’t intersect any other feature in another feature class

classmethod qa_must_intersect_other_1(feature_classes: List[BaseDataset], other_feature_classes: List[BaseDataset], relevant_relation_condition: str) → Condition

Finds features that don’t intersect any feature in a list of other feature classes

classmethod qa_must_touch_other_0(feature_class: BaseDataset, other_feature_class: BaseDataset, relevant_relation_condition: str) → Condition

Finds features that don’t touch any other feature in another feature class

classmethod qa_must_touch_other_1(feature_classes: List[BaseDataset], other_feature_classes: List[BaseDataset], relevant_relation_condition: str) → Condition

Finds features in a list of feature classes that don’t touch any other feature in another list of feature classes

classmethod qa_must_touch_self_0(feature_class: BaseDataset, relevant_relation_condition: str) → Condition

Finds features that don’t touch any other feature in the same feature class

classmethod qa_must_touch_self_1(feature_classes: List[BaseDataset], relevant_relation_condition: str) → Condition

Finds features in a list of feature classes that don’t touch any other feature in the same list of feature classes

classmethod qa_neighbour_areas_0(polygon_class: BaseDataset, constraint: str) → Condition

Finds all touching features in ‘polygonClass’ that do not fulfill ‘constraint’

classmethod qa_neighbour_areas_1(polygon_class: BaseDataset, constraint: str, allow_point_intersection: bool) → Condition

Finds all touching features in ‘polygonClass’ that do not fulfill ‘constraint’. Optionally allows to ignore polygon pairs that intersect in points only.

classmethod qa_neighbour_areas_2(polygon_class: BaseDataset, allow_point_intersection: bool) → Condition

Finds all touching features in ‘polygonClass’ for which all values of editable attributes are equal. Optionally allows to ignore polygon pairs that intersect in points only.

classmethod qa_neighbour_areas_3(polygon_class: BaseDataset, allow_point_intersection: bool, fields_string: str, field_list_type: FieldListType) → Condition

Finds all touching features in ‘polygonClass’ for which the values of a defined list of fields are equal. This field list can be defined by a concatenated string of either relevant or ignored fields. Optionally allows to ignore polygon pairs that intersect in points only.

classmethod qa_neighbour_areas_4(polygon_class: BaseDataset, allow_point_intersection: bool, fields: List[str], field_list_type: FieldListType) → Condition

Finds all touching features in ‘polygonClass’ for which the values of a defined list of fields are equal. This field list can be defined by a list of either relevant or ignored fields. Optionally allows to ignore polygon pairs that intersect in points only.

classmethod qa_no_boundary_loops_0(polygon_class: BaseDataset) → Condition

Finds all boundary loops (closed ‘bays’ in polygon boundaries or multipatch rings) in a polygon or multipatch feature class and reports them as polygon errors.

classmethod qa_no_boundary_loops_1(polygon_class: BaseDataset, error_geometry: BoundaryLoopErrorGeometry) → Condition

Finds all boundary loops (closed ‘bays’ in polygon boundaries or multipatch rings) in a polygon or multipatch feature class and reports them optionally as polygon errors or as point errors identifying the location where the boundary loop starts/ends.

classmethod qa_no_boundary_loops_2(polygon_class: BaseDataset, error_geometry: BoundaryLoopErrorGeometry, area_relation: BoundaryLoopAreaRelation, area_limit: float) → Condition

Finds all boundary loops (closed ‘bays’ in polygon boundaries or multipatch rings) in a polygon or multipatch feature class and reports them optionally as polygon errors or as point errors identifying the location where the boundary loop starts/ends.

Optionally, loops larger or smaller than a given area limit can be ignored. This can be useful together with ‘errorGeometry’ to report loop start points specifically for large loops (in addition to reporting the loop polygons reported by a separate test), where it would otherwise be tedious to locate this start point visually.

classmethod qa_no_closed_paths_0(poly_line_class: BaseDataset) → Condition

Finds closed paths (loops) in polyline features

classmethod qa_no_gaps_0(polygon_class: BaseDataset, sliver_limit: float, max_area: float) → Condition

Finds areas in ‘polygonClass’ with no covering features ( = gaps)

classmethod qa_no_gaps_1(polygon_classes: List[BaseDataset], sliver_limit: float, max_area: float) → Condition

Finds areas that are not covered by any feature out of ‘polygonClasses’ ( = gaps)

classmethod qa_no_gaps_2(polygon_class: BaseDataset, sliver_limit: float, max_area: float, subtile_width: float, find_gaps_below_tolerance: bool) → Condition

Finds areas in ‘polygonClass’ with no covering features ( = gaps)

classmethod qa_no_gaps_3(polygon_classes: List[BaseDataset], sliver_limit: float, max_area: float, subtile_width: float, find_gaps_below_tolerance: bool) → Condition

Finds areas that are not covered by any feature out of ‘polygonClasses’ ( = gaps)

classmethod qa_no_gaps_4(polygon_classes: List[BaseDataset], sliver_limit: float, max_area: float, area_of_interest_classes: List[BaseDataset]) → Condition

Finds areas inside polygons in ‘areaOfInterestClasses’ that are not covered by any feature out of ‘polygonClasses’ ( = gaps)

classmethod qa_no_gaps_5(polygon_classes: List[BaseDataset], sliver_limit: float, max_area: float, subtile_width: float, find_gaps_below_tolerance: bool, area_of_interest_classes: List[BaseDataset]) → Condition

Finds areas inside polygons in ‘areaOfInterestClasses’ that are not covered by any feature out of ‘polygonClasses’ ( = gaps)

classmethod qa_no_touching_parts_0(feature_class: BaseDataset) → Condition

Finds points in polygon or polyline features where parts of the same feature touch

classmethod qa_node_line_coincidence_0(node_class: BaseDataset, near_classes: List[BaseDataset], near: float, coincidence_tolerance: float = -1) → Condition

Finds nodes in ‘nodeClass’ that are not coincident with any feature in ‘nearClasses’, but are within ‘near’ of at least one feature in ‘nearClasses’

classmethod qa_node_line_coincidence_1(node_class: BaseDataset, near_classes: List[BaseDataset], near: float, ignore_near_endpoints: bool, coincidence_tolerance: float = -1) → Condition

Finds nodes in ‘nodeClass’ that are not coincident with any feature in ‘nearClasses’, but are within ‘near’ of at least one feature in ‘nearClasses’. Optionally, only nodes near an edge but no end point are reported. This permits avoiding multiple errors when applying other tests to check for minimum node distance.

classmethod qa_node_line_coincidence_2(node_class: BaseDataset, near_classes: List[BaseDataset], near: float, ignore_near_endpoints: bool, is3_d: bool, coincidence_tolerance: float = -1) → Condition

Finds nodes in ‘nodeClass’ that are not coincident with any feature in ‘nearClasses’, but are within ‘near’ of at least one feature in ‘nearClasses’. Optionally, only nodes near an edge but no end point are reported. This permits avoiding multiple errors when applying other tests to check for minimum node distance.

classmethod qa_node_line_coincidence_3(node_class: BaseDataset, near_classes: List[BaseDataset], near_tolerances: List[float], within_polyline_tolerance: float, ignore_near_endpoints: bool, is3_d: bool, coincidence_tolerance: float = -1) → Condition

Finds nodes in ‘nodeClass’ that are not coincident with any feature in ‘nearClasses’, but are within ‘near’ of at least one feature in ‘nearClasses’. Optionally, individual tolerances can be specified for each feature class in ‘nearClasses’, and for testing within multiple polyline paths in ‘nodeClass’. Optionally, only nodes near an edge but no end point are reported. This permits avoiding multiple errors when applying other tests to check for minimum node distance.

classmethod qa_non_empty_geometry_0(feature_class: BaseDataset) → Condition

Finds all features in ‘featureClass’ with null or empty geometries.

classmethod qa_non_empty_geometry_1(feature_class: BaseDataset, dont_filter_polycurves_by_zero_length: bool) → Condition

Finds all features in ‘featureClass’ with null or empty geometries.

classmethod qa_not_near_0(feature_class: BaseDataset, near: float, min_length: float, is3_d: bool, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_not_near_1(feature_class: BaseDataset, near: float, min_length: float, is3_d: bool, tile_size: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_not_near_2(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, is3_d: bool, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_not_near_3(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, is3_d: bool, tile_size: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_not_near_4(feature_class: BaseDataset, near: float, min_length: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_not_near_5(feature_class: BaseDataset, near: float, min_length: float, tile_size: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_not_near_6(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_not_near_7(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, tile_size: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_orphan_node_0(point_classes: List[BaseDataset], polyline_classes: List[BaseDataset]) → Condition

Finds all points in ‘pointClasses’ that are neither From- nor To-point of any feature in ‘polylineClasses’ and line end points without any point

Remark: All feature classes in ‘pointClasses’ and ‘polylineClasses’ must have the same spatial reference.

classmethod qa_orphan_node_1(point_class: BaseDataset, polyline_class: BaseDataset) → Condition

Finds all points in ‘pointClass’ that are neither From- nor To-point of any feature in ‘polylineClass’ and line end points without any point

Remark: The feature classes in ‘pointClass’ and ‘polylineClass’ must have the same spatial reference.

classmethod qa_orphan_node_2(point_classes: List[BaseDataset], polyline_classes: List[BaseDataset], error_type: OrphanErrorType) → Condition

Finds all points in ‘pointClasses’ that are neither From- nor To-point of any feature in ‘polylineClasses’ and/or line end points without any point Performs the tests defined in ‘errorType’.

Remark: All feature classes in ‘pointClasses’ and ‘polylineClasses’ must have the same spatial reference.

classmethod qa_orphan_node_3(point_class: BaseDataset, polyline_class: BaseDataset, error_type: OrphanErrorType) → Condition

Finds all points in ‘pointClass’ that are neither From- nor To-point of any feature in ‘polylineClass’ and/or line end points without any point Performs the tests defined in ‘errorType’.

Remark: The feature classes in ‘pointClass’ and ‘polylineClass’ must have the same spatial reference.

classmethod qa_overlaps_other_0(overlapped: List[BaseDataset], overlapping: List[BaseDataset]) → Condition

Finds features in ‘overlappingClasses’ overlapping with any feature in ‘overlappedClasses’

Remark: All feature classes in ‘overlappedClasses’ and ‘overlappingClasses’ must have the same spatial reference.

classmethod qa_overlaps_other_1(overlapped: BaseDataset, overlapping: BaseDataset) → Condition

Finds features in ‘overlappingClass’ overlapping with any feature in ‘overlappedClass’

Remark: The feature classes ‘overlappedClass’ and ‘overlappingClass’ must have the same spatial reference.

classmethod qa_overlaps_other_2(overlapped_classes: List[BaseDataset], overlapping_classes: List[BaseDataset], valid_relation_constraint: str) → Condition

Finds features in ‘overlappingClasses’ overlapping with any feature in ‘overlappedClasses’, and for which a given constraint is not fulfilled.

Remark: All feature classes in ‘overlappedClasses’ and ‘overlappingClasses’ must have the same spatial reference.

classmethod qa_overlaps_other_3(overlapped_class: BaseDataset, overlapping_class: BaseDataset, valid_relation_constraint: str) → Condition

Finds features in ‘overlappingClass’ overlapping with any feature in ‘overlappedClass’, and for which a given constraint is not fulfilled.

Remark: The feature classes ‘overlappedClass’ and ‘overlappingClass’ must have the same spatial reference.

classmethod qa_overlaps_self_0(feature_class: BaseDataset) → Condition

Finds all features in ‘featureClass’ that overlap any feature in ‘featureClass’

classmethod qa_overlaps_self_1(feature_classes: List[BaseDataset]) → Condition

Finds all features in ‘featureClasses’ that overlap any feature in ‘featureClasses’

classmethod qa_overlaps_self_2(feature_classes: List[BaseDataset], valid_relation_constraint: str) → Condition

Finds all features in ‘featureClasses’ that overlap any feature in ‘featureClasses’, and for which a given constraint is not fulfilled.

classmethod qa_overlaps_self_3(feature_class: BaseDataset, valid_relation_constraint: str) → Condition

Finds all features in ‘featureClass’ that overlap any feature in ‘featureClass’, and for which a given constraint is not fulfilled.

classmethod qa_part_coincidence_other_0(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, is3_d: bool, ignore_neighbor_condition: Optional[str] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClass’, that lie nearer than ‘near’ to lines in ‘reference’ but are not coincident.

Remark: All feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_part_coincidence_other_1(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, is3_d: bool, tile_size: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClass’, that lie nearer than ‘near’ to lines in ‘reference’ but are not coincident.

Remark: All feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_part_coincidence_other_2(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClass’, that lie nearer than ‘near’ to lines in ‘reference’ but are not coincident.

Remark: All feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_part_coincidence_other_3(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, tile_size: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClass’, that lie nearer than ‘near’ to lines in ‘reference’ but are not coincident.

Remark: All feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_part_coincidence_other_4(feature_class: BaseDataset, reference: BaseDataset, near: float, connected_min_length: float, disjoint_min_length: float, is3_d: bool, tile_size: float, coincidence_tolerance: float, ignore_neighbor_condition: Optional[str] = None) → Condition

Find line sections longer than a specified minimum length in ‘featureClass’, that lie nearer than ‘near’ to lines in ‘reference’ but are not coincident. The minimum length can be defined separately for line pairs that are connected (‘connectedMinLength’) or disjoint (‘disjointMinLength’). A coincidence tolerance can be specified to indicate a maximum allowed offset between the lines at which they are still considered to be coincident.

Remark: All feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_part_coincidence_self_0(feature_class: BaseDataset, near: float, min_length: float, is3_d: bool, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClass’, where 2 non-coincident lines lie nearer than ‘near’ but are not coincident.

classmethod qa_part_coincidence_self_1(feature_class: BaseDataset, near: float, min_length: float, is3_d: bool, tile_size: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClass’, where 2 non-coincident lines lie nearer than ‘near’ but are not coincident.

classmethod qa_part_coincidence_self_2(feature_classes: List[BaseDataset], near: float, min_length: float, is3_d: bool, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClasses’, where 2 non-coincident lines lie nearer than ‘near’, but are not coincident.

Remark: All feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_part_coincidence_self_3(feature_classes: List[BaseDataset], near: float, min_length: float, is3_d: bool, tile_size: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClasses’, where 2 non-coincident lines lie nearer than ‘near’, but are not coincident.

Remark: All feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_part_coincidence_self_4(feature_classes: List[BaseDataset], near: float, min_length: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClasses’, where 2 non-coincident lines lie nearer than ‘near’, but are not coincident.

Remark: All feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_part_coincidence_self_5(feature_classes: List[BaseDataset], near: float, min_length: float, tile_size: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Find line sections longer than ‘minLength’ in ‘featureClasses’, where 2 non-coincident lines lie nearer than ‘near’, but are not coincident.

Remark: All feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_part_coincidence_self_6(feature_classes: List[BaseDataset], near: float, connected_min_length: float, disjoint_min_length: float, is3_d: bool, tile_size: float, coincidence_tolerance: float, ignore_neighbor_conditions: Optional[List[str]] = None) → Condition

Find line sections longer than a specified minimum length in ‘featureClasses’, where 2 non-coincident lines lie nearer than ‘near’, but are not coincident. The minimum length can be defined separately for line pairs that are connected (‘connectedMinLength’) or disjoint (‘disjointMinLength’). A coincidence tolerance can be specified to indicate a maximum allowed offset between the lines at which they are still considered to be coincident.

Remark: All feature classes in ‘featureClasses’ must have the same spatial reference.

classmethod qa_point_not_near_0(point_class: BaseDataset, reference_class: BaseDataset, limit: float, allow_coincident_points: bool = False, geometry_components: List[GeometryComponent] = 0, valid_relation_constraints: Optional[List[str]] = None, minimum_error_line_length: float = -1) → Condition

Finds points in ‘pointClass’ that are closer than ‘limit’ to feature geometries (or geometry components) in ‘referenceClass’.

classmethod qa_point_not_near_1(point_class: BaseDataset, reference_classes: List[BaseDataset], limit: float, allow_coincident_points: bool = False, geometry_components: List[GeometryComponent] = 0, valid_relation_constraints: Optional[List[str]] = None, minimum_error_line_length: float = -1) → Condition

Finds points in ‘pointClass’ that are closer than ‘limit’ to feature geometries (or geometry components) in ‘referenceClasses’.

classmethod qa_point_not_near_2(point_class: BaseDataset, reference_classes: List[BaseDataset], search_distance: float, point_distance_expression: str, reference_distance_expressions: List[str], allow_coincident_points: bool = False, geometry_components: List[GeometryComponent] = 0, valid_relation_constraints: Optional[List[str]] = None, minimum_error_line_length: float = -1) → Condition

Finds points in ‘pointClass’ that are closer to feature geometries (or geometry components) in ‘referenceClasses’ than the sum of distances derived from attribute expressions for the point feature and a reference feature.

classmethod qa_point_not_near_3(point_class: BaseDataset, reference_classes: List[BaseDataset], search_distance: float, point_distance_expression: str, reference_distance_expressions: List[str], reference_right_side_distances: List[str], reference_flip_expressions: List[str], allow_coincident_points: bool = False, geometry_components: List[GeometryComponent] = 0, valid_relation_constraints: Optional[List[str]] = None, minimum_error_line_length: float = -1) → Condition

Finds points in ‘pointClass’ that are closer to feature geometries (or geometry components) in ‘referenceClasses’ than the sum of distances derived from attribute expressions for the point feature and a reference feature. The reference feature distances can be defined for both sides of line features or polygon boundaries, with the option to swap left / right sides (as defined by the line direction) based on an attribute expression or constant.

classmethod qa_point_on_line_0(point_class: BaseDataset, near_classes: List[BaseDataset], near: float) → Condition

Finds all points in ‘pointClass’ not nearer than ‘near’ to any feature of ‘nearClasses’

Remark: All feature classes in ‘pointClass’ and ‘nearClasses’ must have the same spatial reference.

classmethod qa_pseudo_nodes_1(polyline_class: BaseDataset, ignore_fields: List[str], valid_pseudo_node: BaseDataset, ignore_loop_endpoints: bool = False) → Condition

Finds pseudo nodes: Finds all endpoints in ‘polylineClass’, that correspond to exactly 2 From-/To-points of ‘polylineClass’, the attributes values of the involved features do not differ and they are not separated by a point out of ‘validPseudoNode’

Remark: The feature classes in ‘validPseudoNode’ and ‘polylineClass’ must have the same spatial reference.

classmethod qa_pseudo_nodes_3(polyline_class: BaseDataset, ignore_fields: List[str], ignore_loop_endpoints: bool = False) → Condition

Finds pseudo nodes: Finds all endpoints in ‘polylineClass’, that correspond to exactly 2 From-/To-points and the attributes values of the involved features do not differ

classmethod qa_pseudo_nodes_4(polyline_classes: List[BaseDataset], ignore_field_lists: List[str], valid_pseudo_nodes: List[BaseDataset], ignore_loop_endpoints: bool = False) → Condition

Finds pseudo nodes: Finds all endpoints in ‘polylineClasses’, that correspond to exactly 2 From-/To-points of ‘polylineClasses’, the two involved features belong to the same feature class, the attributes values of the involved features do not differ and they are not separated by a point out of ‘validPseudoNodes’

Remark: All feature classes in ‘polylineClasses’ and ‘validPseudoNodes’ must have the same spatial reference.

classmethod qa_pseudo_nodes_5(polyline_classes: List[BaseDataset], ignore_field_lists: List[str], ignore_loop_endpoints: bool = False) → Condition

Finds pseudo nodes: Finds all endpoints in ‘polylineClasses’, that correspond to exactly 2 From-/To-points of ‘polylineClasses’, the two involved features belong to the same feature class and the attributes values of the involved features do not differ

Remark: The feature classes in ‘polylineClasses’ must have the same spatial reference.

classmethod qa_regular_expression_0(table: BaseDataset, pattern: str, field_name: str, field_list_type: FieldListType = 1) → Condition

Finds rows with values that do not match a defined regular expression

classmethod qa_regular_expression_1(table: BaseDataset, pattern: str, field_names: List[str], field_list_type: FieldListType = 1) → Condition

Finds rows with values that do not match a defined regular expression

classmethod qa_regular_expression_2(table: BaseDataset, pattern: str, field_name: str, match_is_error: bool, field_list_type: FieldListType = 1) → Condition

Finds rows with values that do not match a defined regular expression. Optionally, a match can be considered an error.

classmethod qa_regular_expression_3(table: BaseDataset, pattern: str, field_names: List[str], match_is_error: bool, field_list_type: FieldListType = 1) → Condition

Finds rows with values that do not match a defined regular expression. Optionally, a match can be considered an error.

classmethod qa_regular_expression_4(table: BaseDataset, pattern: str, field_name: str, match_is_error: bool, pattern_description: str, field_list_type: FieldListType = 1) → Condition

Finds rows with values that do not match a defined regular expression. Optionally, a match can be considered an error.

classmethod qa_regular_expression_5(table: BaseDataset, pattern: str, field_names: List[str], match_is_error: bool, pattern_description: str, field_list_type: FieldListType = 1) → Condition

Finds rows with values that do not match a defined regular expression. Optionally, a match can be considered an error.

classmethod qa_rel_constraint(relation_tables: List[BaseDataset], relation: str, join: JoinType, constraint: List[str], apply_filter_expressions_in_database: bool = False) → Condition

Finds all rows in the joined table that do not fulfill ‘constraint’

classmethod qa_rel_group_connected(relation_tables: List[BaseDataset], relation: str, join: JoinType, group_by: List[str], allowed_shape: ShapeAllowed, report_individual_gaps: bool = False, ignore_gaps_longer_than: float = -1, complete_groups_outside_test_area: bool = False, error_reporting: GroupErrorReporting = 1) → Condition

Find errors in checking if polylines of a joined table with same attributes are connected

classmethod qa_rel_group_constraints(relation_tables: List[BaseDataset], relation: str, join: JoinType, group_by_expression: str, distinct_expression: str, max_distinct_count: int, limit_to_tested_rows: bool, exists_row_group_filter: Optional[str] = None) → Condition

Checks if the number of distinct values of an expression (which may be a single field or a more complex expression involving field concatenation, value translation, substring extraction etc.) within groups defined by a ‘group by’ expression (which also may be a single field or a more complex expression on fields) does not exceed an allowed maximum value. The expressions are evaluated in a joined view of two tables.

classmethod qa_rel_line_group_constraints(relation_tables: List[BaseDataset], relation: str, join: JoinType, min_gap: float, min_group_length: float, min_dangle_length: float, group_by: str, group_condition: Optional[str] = None, value_separator: Optional[str] = None, min_gap_to_other_group_type: float = 0, min_dangle_length_continued: float = 0, min_dangle_length_at_fork_continued: float = 0, min_dangle_length_at_fork: float = 0, min_gap_to_same_group_type_covered: float = 0, min_gap_to_same_group_type_at_fork: float = 0, min_gap_to_same_group_type_at_fork_covered: float = 0, min_gap_to_other_group_type_at_fork: float = 0, min_gap_to_same_group: float = 0) → Condition

Find errors in checking if connected polylines of a joined table with same attributes related to ‘groupBy’ meet the conditions defined by the parameters

classmethod qa_rel_must_be_near_other(relation_tables: List[BaseDataset], relation: str, join: JoinType, near_classes: List[BaseDataset], maximum_distance: float, relevant_relation_condition: str, error_distance_format: Optional[str] = None) → Condition

Finds all features in a joined table that are not closer than ‘maximumDistance’ to any feature of ‘nearClasses’, or for which nearby features in ‘nearClasses’ do exist, but a given comparison constraint is not fulfilled. Note that errors can be reported only for features that are completely within the verified extent. Features that extend beyond the verified extent may have valid neighbors outside of the searched extent, and are therefore ignored.

classmethod qa_rel_regular_expression(relation_tables: List[BaseDataset], relation: str, join: JoinType, pattern: str, field_names: List[str], match_is_error: bool = False, pattern_description: Optional[str] = None) → Condition

Finds all rows in the joined table that do not fulfill ‘constraint’

classmethod qa_rel_unique(relation_tables: List[BaseDataset], relation: str, join: JoinType, unique: str, max_rows: int) → Condition

Find all none unique rows in a joined table

classmethod qa_required_fields_0(table: BaseDataset, required_field_names: List[str]) → Condition

Finds rows with null values for a given list of required fields

classmethod qa_required_fields_1(table: BaseDataset, required_field_names: List[str], allow_empty_strings: bool) → Condition

Finds rows with null values for a given list of required fields

classmethod qa_required_fields_2(table: BaseDataset, required_field_names: List[str], allow_empty_strings: bool, allow_missing_fields: bool) → Condition

Finds rows with null values for a given list of required fields

classmethod qa_required_fields_3(table: BaseDataset, required_field_names_string: str, allow_empty_strings: bool, allow_missing_fields: bool) → Condition

Finds rows with null values for a given list of required fields

classmethod qa_required_fields_4(table: BaseDataset, allow_empty_strings: bool) → Condition

Finds rows with null values for a given list of required fields

classmethod qa_route_measures_continuous_0(polyline_class: BaseDataset, route_id_field: str) → Condition

Finds discontinuities in the M values at connections between line features of the same route.

The connecting end points of lines within the same route must have the same M values, otherwise an error is reported. M values with a difference smaller than the M tolerance of the spatial reference are considered equal.

classmethod qa_route_measures_continuous_1(polyline_classes: List[BaseDataset], route_id_fields: List[str]) → Condition

Finds discontinuities in the M values at connections between line features of the same route.

The connecting end points of lines within the same route must have the same M values, otherwise an error is reported. M values with a difference smaller than the M tolerance of the spatial reference are considered equal.

classmethod qa_route_measures_unique_0(polyline_class: BaseDataset, route_id_field: str) → Condition

Finds segment sequences within line features belonging to the same route that have the same measure values. Both non-unique measure ranges from different features, and non-unique measures within a single feature (due to non-monotonic measures) are reported.

classmethod qa_route_measures_unique_1(polyline_classes: List[BaseDataset], route_id_fields: List[str]) → Condition

Finds segment sequences within line features belonging to the same route that have the same measure values. Both non-unique measure ranges from different features, and non-unique measures within a single feature (due to non-monotonic measures) are reported.

classmethod qa_row_count_0(table: BaseDataset, minimum_row_count: int, maximum_row_count: int) → Condition

Determines if the number of rows in a table is within an expected range

classmethod qa_row_count_1(table: BaseDataset, reference_tables: List[BaseDataset], minimum_value_offset: str, maximum_value_offset: str) → Condition

Determines if the number of rows in a table is within an expected range, defined based on offsets from the row count in one or more reference tables. This can be used to check if a copy / append operation from one or more source tables to a target table was successful.

classmethod qa_schema_field_aliases_0(table: BaseDataset, maximum_length: int, expected_case: ExpectedCase, require_unique_alias_names: bool, allow_custom_system_field_alias: bool) → Condition

Finds fields with invalid alias names.

classmethod qa_schema_field_aliases_1(table: BaseDataset, maximum_length: int, expected_case: ExpectedCase, require_unique_alias_names: bool, allow_custom_system_field_alias: bool, expected_difference: ExpectedStringDifference) → Condition

Finds fields with invalid alias names.

classmethod qa_schema_field_domain_coded_values_0(table: BaseDataset, maximum_name_length: int, unique_names_constraint: UniqueStringsConstraint, minimum_value_count: int, minimum_non_equal_name_value_count: int, allow_empty_name: bool) → Condition

Finds coded value domains referenced from a table that have invalid coded values lists.

classmethod qa_schema_field_domain_descriptions_0(table: BaseDataset, maximum_length: int, require_unique_descriptions: bool, target_workspace_table: BaseDataset) → Condition

Finds domains with invalid domain descriptions.

classmethod qa_schema_field_domain_descriptions_1(table: BaseDataset, maximum_length: int, require_unique_descriptions: bool) → Condition

Finds domains with invalid domain descriptions.

classmethod qa_schema_field_domain_name_regex_0(table: BaseDataset, pattern: str, match_is_error: bool, pattern_description: str) → Condition

Finds domains referenced from a table whose names do not match a defined regular expression.

classmethod qa_schema_field_domain_names_0(table: BaseDataset, expected_prefix: str, maximum_length: int, must_contain_field_name: bool, expected_case: ExpectedCase) → Condition

Finds domains referenced from a table that have invalid names.

classmethod qa_schema_field_domains_0(table: BaseDataset) → Condition

Finds domains referenced from a table that are not valid for the referencing field (due to a data type mismatch).

classmethod qa_schema_field_name_regex_0(table: BaseDataset, pattern: str, match_is_error: bool, pattern_description: str) → Condition

Finds field names that do not match a defined regular expression.

classmethod qa_schema_field_names_0(table: BaseDataset, maximum_length: int, expected_case: ExpectedCase, unique_substring_length: int) → Condition

Finds fields with invalid names.

classmethod qa_schema_field_properties_0(table: BaseDataset, field_name: str, expected_field_type: esriFieldType, expected_field_length: int, expected_alias_name: str, expected_domain_name: str, field_is_optional: bool) → Condition

Verifies if a field has expected properties

classmethod qa_schema_field_properties_from_table_0(table: BaseDataset, field_specifications_table: BaseDataset, match_alias_name: bool) → Condition

Verifies that fields have expected properties based on a list of field specifications defined in another table. The field specifications table can be filtered to a subset of rows relevant for the verified table.

classmethod qa_schema_reserved_field_name_properties_0(table: BaseDataset, reserved_names_table: BaseDataset, reserved_name_field_name: str, reserved_reason_field_name: str, valid_name_field_name: str, field_specifications_table: BaseDataset) → Condition

Finds fields that have a reserved field name, based on a table containing reserved names, and optionally a reason why a name is reserved and a valid name that should be used instead.

classmethod qa_schema_reserved_field_names_0(table: BaseDataset, reserved_names: List[str]) → Condition

Finds fields that have a reserved field name, based on a list of reserved names.

classmethod qa_schema_reserved_field_names_1(table: BaseDataset, reserved_names_string: str) → Condition

Finds fields that have a reserved field name, based on a concatenated string of reserved names.

classmethod qa_schema_reserved_field_names_2(table: BaseDataset, reserved_names_table: BaseDataset, reserved_name_field_name: str, reserved_reason_field_name: str, valid_name_field_name: str) → Condition

Finds fields that have a reserved field name, based on a table containing reserved names, and optionally a reason why a name is reserved and a valid name that should be used instead.

classmethod qa_schema_spatial_reference_0(feature_class: BaseDataset, reference_feature_class: BaseDataset, compare_x_y_precision: bool, compare_z_precision: bool, compare_m_precision: bool, compare_tolerances: bool, compare_vertical_coordinate_systems: bool, compare_x_y_domain_origin: bool = False, compare_z_domain_origin: bool = False, compare_m_domain_origin: bool = False, compare_x_y_resolution: bool = False, compare_z_resolution: bool = False, compare_m_resolution: bool = False) → Condition

Checks if the spatial reference of a feature class is exactly (including domain, tolerance and resolution) equal to the spatial reference of a reference feature class.

classmethod qa_schema_spatial_reference_1(feature_class: BaseDataset, spatial_reference_xml: str, compare_x_y_precision: bool, compare_z_precision: bool, compare_m_precision: bool, compare_tolerances: bool, compare_vertical_coordinate_systems: bool, compare_x_y_domain_origin: bool = False, compare_z_domain_origin: bool = False, compare_m_domain_origin: bool = False, compare_x_y_resolution: bool = False, compare_z_resolution: bool = False, compare_m_resolution: bool = False) → Condition

Checks if the spatial reference of a feature class is exactly (including domain, tolerance and resolution) equal to the spatial reference defined in an spatial reference xml string.

classmethod qa_schema_spatial_reference_2(feature_class: BaseDataset, reference_feature_class: BaseDataset, compare_used_precisions: bool, compare_tolerances: bool, compare_vertical_coordinate_systems: bool, compare_x_y_domain_origin: bool = False, compare_z_domain_origin: bool = False, compare_m_domain_origin: bool = False, compare_x_y_resolution: bool = False, compare_z_resolution: bool = False, compare_m_resolution: bool = False) → Condition

Checks if the spatial reference of ‘featureClass’ is exactly (including domain, tolerance and resolution) equal to the spatial reference of ‘referenceFeatureClass’.

classmethod qa_schema_spatial_reference_3(feature_class: BaseDataset, spatial_reference_xml: str, compare_used_precisions: bool, compare_tolerances: bool, compare_vertical_coordinate_systems: bool, compare_x_y_domain_origin: bool = False, compare_z_domain_origin: bool = False, compare_m_domain_origin: bool = False, compare_x_y_resolution: bool = False, compare_z_resolution: bool = False, compare_m_resolution: bool = False) → Condition

Checks if the spatial reference of ‘featureClass’ is exactly (including domain, tolerance and resolution) equal to the spatial reference defined in ‘spatialReferenceXml’ string.

classmethod qa_segment_length_0(feature_class: BaseDataset, limit: float, is3_d: bool) → Condition

Find all segments in ‘featureClass’ smaller than ‘limit’

classmethod qa_segment_length_1(feature_class: BaseDataset, limit: float) → Condition

Find all segments in ‘featureClass’ smaller than ‘limit’

classmethod qa_simple_geometry_0(feature_class: BaseDataset) → Condition

Finds all features in ‘featureClass’ with non-simple geometries

classmethod qa_simple_geometry_1(feature_class: BaseDataset, allow_non_planar_lines: bool) → Condition

Finds all features in ‘featureClass’ with non-simple geometries. Optionally ignores non-planar (self-intersecting) lines

classmethod qa_simple_geometry_2(feature_class: BaseDataset, allow_non_planar_lines: bool, tolerance_factor: float) → Condition

Finds all features in ‘featureClass’ with non-simple geometries. Optionally ignores non-planar (self-intersecting) lines, and allows specifying a custom factor for reducing the spatial reference xy tolerance used in the detection of non-simple geometries.

classmethod qa_sliver_polygon_0(polygon_class: BaseDataset, limit: float) → Condition

Finds all sliver polygons in ‘polygonClass’

classmethod qa_sliver_polygon_1(polygon_class: BaseDataset, limit: float, max_area: float) → Condition

Finds all sliver polygons in ‘polygonClass’

classmethod qa_smooth_0(feature_class: BaseDataset, limit: float, angular_unit: AngleUnit = 0) → Condition

Finds all segments in ‘featureClass’ where the discretized second derivative of the slope angle exceeds ‘limit’. This means that there are to abrupt changes in the slope angle.

classmethod qa_topo_not_near_0(feature_class: BaseDataset, near: float, min_length: float, is3_d: bool, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_topo_not_near_1(feature_class: BaseDataset, near: float, min_length: float, is3_d: bool, tile_size: float, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_topo_not_near_10(feature_class: BaseDataset, reference: BaseDataset, near: float, feature_class_near: str, reference_near: str, connected_min_length_factor: float, default_unconnected_min_length_factor: float, is3_d: bool, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_topo_not_near_2(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, is3_d: bool, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_topo_not_near_3(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, is3_d: bool, tile_size: float, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_topo_not_near_4(feature_class: BaseDataset, near: float, min_length: float, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_topo_not_near_5(feature_class: BaseDataset, near: float, min_length: float, tile_size: float, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections longer than ‘minLength’ in ‘featureClass’ that are closer than ‘near’ to any other line in ‘featureClass’.

classmethod qa_topo_not_near_6(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_topo_not_near_7(feature_class: BaseDataset, reference: BaseDataset, near: float, min_length: float, tile_size: float, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_topo_not_near_8(feature_class: BaseDataset, near: float, near_expression: str, connected_min_length_factor: float, default_unconnected_min_length_factor: float, is3_d: bool, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

classmethod qa_topo_not_near_9(feature_class: BaseDataset, reference: BaseDataset, near: float, connected_min_length_factor: float, default_unconnected_min_length_factor: float, is3_d: bool, crossing_min_length_factor: float = -1, not_reported_condition: Optional[str] = None, ignore_neighbor_condition: Optional[str] = None, junction_coincidence_tolerance: float = 0, connection_mode: ConnectionMode = 1, unconnected_line_cap_style: LineCapStyle = 0, ignore_loops_within_near_distance: bool = False, ignore_inconsistent_line_symbol_ends: bool = False, allow_coincident_sections: bool = False, right_side_nears: Optional[List[str]] = None, end_cap_style: LineCapStyle = 0, junction_is_end_expression: Optional[str] = None) → Condition

Finds all line sections in ‘featureClass’ longer than ‘minLength’ that are closer than ‘near’ to any line in ‘reference’.

Remark: The feature classes in ‘featureClass’ and ‘reference’ must have the same spatial reference.

classmethod qa_topo_not_near_poly_factory(feature_class: BaseDataset, reference: BaseDataset, reference_subtypes: List[int], featuresubtype_rules: List[str]) → Condition

Find features of ‘featureClass’ that intersect ‘reference’ when buffered according to ‘featuresubtypeRules’.

Remark: For line ends that are not coincident to any other line end (=dangles), a flat end buffer is used.

Remark: The configuration can be exported/imported to/from a csv-File for easier configuration. if <referenceSubtypes> and <featuresubtypeRules> are empty, a matrix with all available subtypes is created when exporting the quality condition.

classmethod qa_touches_other_0(touching: List[BaseDataset], touched: List[BaseDataset], valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘touchedClasses’ that are touched by features in ‘touchingClasses’

classmethod qa_touches_other_1(touching: BaseDataset, touched: BaseDataset, valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘touchedClass’ that are touched by features in ‘touchingClass’

classmethod qa_touches_other_2(touching: List[BaseDataset], touched: List[BaseDataset], valid_relation_constraint: str, valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘touchedClasses’ that are touched by features in ‘touchingClasses’, and for which a given constraint is not fulfilled.

classmethod qa_touches_other_3(touching: BaseDataset, touched: BaseDataset, valid_relation_constraint: str, valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘touchedClass’ that are touched by features in ‘touchingClass’, and for which a given constraint is not fulfilled.

classmethod qa_touches_self_0(feature_classes: List[BaseDataset], valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘featureClasses’ that are touched by other features in ‘featureClasses’

classmethod qa_touches_self_1(feature_class: BaseDataset, valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘featureClass’ that are touched by other features in ‘featureClass’

classmethod qa_touches_self_2(feature_classes: List[BaseDataset], valid_relation_constraint: str, valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘featureClasses’ that are touched by other features in ‘featureClasses’, and for which a given constraint is not fulfilled.

classmethod qa_touches_self_3(feature_class: BaseDataset, valid_relation_constraint: str, valid_touch_geometry_constraint: Optional[str] = None) → Condition

Finds all features in ‘featureClass’ that are touched by other features in ‘featureClass’, and for which a given constraint is not fulfilled.

classmethod qa_trimmed_text_fields_0(table: BaseDataset) → Condition

Finds rows with text fields having leading or trailing whitespace characters. All text fields of the table are checked. Fields with only whitespace characters are also reported.

classmethod qa_trimmed_text_fields_1(table: BaseDataset, allowed_white_space_only_count: int) → Condition

Finds rows with text fields having leading or trailing whitespace characters. All text fields of the table are checked. For fields that contain only whitespace, a maximum number of allowed whitespace characters can specified.

classmethod qa_trimmed_text_fields_2(table: BaseDataset, text_field_name: str) → Condition

Finds rows that have leading or trailing whitespace characters in a specified text field. An error is reported also if the field contains only whitespace characters.

classmethod qa_trimmed_text_fields_3(table: BaseDataset, allowed_white_space_only_count: int, text_field_name: str) → Condition

Finds rows that have leading or trailing whitespace characters in a specified text field. If the field contains only whitespace, a maximum number of allowed whitespace characters can specified.

classmethod qa_trimmed_text_fields_4(table: BaseDataset, allowed_white_space_only_count: int, text_field_names: List[str]) → Condition

Finds rows that have leading or trailing whitespace characters in a given list of text fields. If the field contains only whitespace, a maximum number of allowed whitespace characters can specified.

classmethod qa_trimmed_text_fields_5(table: BaseDataset, allowed_white_space_only_count: int, text_field_names_string: str, field_list_type: FieldListType) → Condition

Finds rows that have leading or trailing whitespace characters in a given list of text fields. The field list can be defined by a concatenated string of either relevant or ignored fields. If the field contains only whitespace, a maximum number of allowed whitespace characters can specified.

classmethod qa_trimmed_text_fields_6(table: BaseDataset, allowed_white_space_only_count: int, text_field_names: List[str], field_list_type: FieldListType) → Condition

Finds rows that have leading or trailing whitespace characters in a given list of text fields. The field list can be defined by a list of either relevant or ignored fields. If the field contains only whitespace, a maximum number of allowed whitespace characters can specified.

classmethod qa_unique_0(table: BaseDataset, unique: str) → Condition

Finds rows in ‘table’ for which the values in the field(s) defined by ‘unique’ are not unique

classmethod qa_unique_1(table: BaseDataset, unique: str, max_rows: int) → Condition

Finds rows in ‘table’ for which the values in the field(s) defined by ‘unique’ are not unique

classmethod qa_unique_2(tables: List[BaseDataset], uniques: List[str]) → Condition

Finds rows in ‘tables’ for which the values in the field(s) defined by ‘uniques’ are not unique across all tables

classmethod qa_unreferenced_rows_0(referenced_table: BaseDataset, referencing_tables: List[BaseDataset], relations: List[str]) → Condition

Finds rows in a table that are not referenced by any row in a collection of referencing tables

classmethod qa_valid_coordinate_fields_0(feature_class: BaseDataset, x_coordinate_field_name: str, y_coordinate_field_name: str, z_coordinate_field_name: str, xy_tolerance: float, z_tolerance: float, culture: str, allow_x_y_field_values_for_undefined_shape: bool = False, allow_z_field_value_for_undefined_shape: bool = False, allow_missing_z_field_value_for_defined_shape: bool = False, allow_missing_x_y_field_value_for_defined_shape: bool = False) → Condition

Finds features with attributes for XY and/or Z coordinate values whose values differ significantly from the coordinates of the feature.

classmethod qa_valid_date_values_0(table: BaseDataset, minimum_date_value: datetime, maximum_date_value: datetime) → Condition

Finds rows with date field values that are invalid or outside a defined date range

classmethod qa_valid_date_values_1(table: BaseDataset, minimum_date_value: datetime, maximum_date_value: datetime, date_field_names: List[str]) → Condition

Finds rows with date values from a given list of date fields that are invalid or outside a defined date range

classmethod qa_valid_date_values_2(table: BaseDataset, minimum_date_value: datetime, maximum_date_value: datetime, date_field_names_string: str) → Condition

Finds rows with date values from a given list of date fields that are invalid or outside a defined date range. The list of date fields can be defined by a concatenated string of field names

classmethod qa_valid_date_values_3(table: BaseDataset, minimum_date_value: datetime, maximum_date_time_relative_to_now: str) → Condition

Finds rows with date field values that are invalid or outside a defined date range. The maximum date value can be specified relative to the current date/time

classmethod qa_valid_date_values_4(table: BaseDataset, minimum_date_value: datetime, maximum_date_time_relative_to_now: str, date_field_names_string: str) → Condition

Finds rows with date values from a given list of date fields that are invalid or outside a defined date range. The list of date fields can be defined by a concatenated string of field names. The maximum date value can be specified relative to the current date/time

classmethod qa_valid_date_values_5(table: BaseDataset, minimum_date_time_relative_to_now: str, maximum_date_value: datetime, date_field_names_string: str) → Condition

Finds rows with date values from a given list of date fields that are invalid or outside a defined date range. The list of date fields can be defined by a concatenated string of field names. The minimum date value can be specified relative to the current date/time

classmethod qa_valid_date_values_6(table: BaseDataset, minimum_date_time_relative_to_now: str, maximum_date_time_relative_to_now: str, date_field_names_string: str) → Condition

Finds rows with date values from a given list of date fields that are invalid or outside a defined date range. The list of date fields can be defined by a concatenated string of field names. The minimum and maximum date values can be specified relative to the current date/time

classmethod qa_valid_non_linear_segments_0(feature_class: BaseDataset) → Condition

Finds features with invalid non-linear segments. Currently, circular arcs that degenerated to a line and therefore have no center point are found.

classmethod qa_valid_non_linear_segments_1(feature_class: BaseDataset, minimum_chord_height: float) → Condition

Finds features with invalid non-linear segments. Currently, circular arcs that degenerated to a line and therefore have no center point are found. Additionally, circular arcs with a chord height smaller than a specified value may be identified.

classmethod qa_valid_urls_0(table: BaseDataset, url_expression: str, maximum_parallel_tasks: int = 1) → Condition

Checks field values in ‘table’ for valid URLs. The URLs can be stored in a single field or it can be the result of a SQL expression referencing one or more fields. Supported are HTTP or file system URLs (UNC paths or paths to mapped drives). FTP URLs are not supported yet

classmethod qa_value_0(table: BaseDataset, fields: List[str]) → Condition

Finds all rows in ‘table’ with invalid data types. This can be the case for GUID-values. The test itself checks all datatypes

classmethod qa_vertex_coincidence_0(feature_class: BaseDataset, point_tolerance: float = -1, edge_tolerance: float = -1, require_vertex_on_nearby_edge: bool = True, coincidence_tolerance: float = 0, is3_d: bool = False, z_tolerance: float = 0, z_coincidence_tolerance: float = 0, report_coordinates: bool = False) → Condition

Finds vertices for which there is no coincident vertex and/or edge within the geometry of features of a given feature class.

classmethod qa_vertex_coincidence_other_0(feature_class: BaseDataset, related_class: BaseDataset, point_tolerance: float = -1, edge_tolerance: float = -1, require_vertex_on_nearby_edge: bool = True, coincidence_tolerance: float = 0, z_tolerance: float = 0, z_coincidence_tolerance: float = 0, is3_d: bool = False, bidirectional: bool = True, report_coordinates: bool = False) → Condition

Finds vertices for which there is no coincident vertex and/or edge in nearby features of another feature class.

classmethod qa_vertex_coincidence_other_1(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], point_tolerance: float = -1, edge_tolerance: float = -1, require_vertex_on_nearby_edge: bool = True, coincidence_tolerance: float = 0, z_tolerance: float = 0, z_coincidence_tolerance: float = 0, is3_d: bool = False, bidirectional: bool = True, report_coordinates: bool = False) → Condition

Finds vertices for which there is no coincident vertex and/or edge in nearby features of a given list of other feature classes.

classmethod qa_vertex_coincidence_other_2(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], allowed_non_coincidence_condition: str, point_tolerance: float = -1, edge_tolerance: float = -1, require_vertex_on_nearby_edge: bool = True, coincidence_tolerance: float = 0, z_tolerance: float = 0, z_coincidence_tolerance: float = 0, is3_d: bool = False, bidirectional: bool = True, report_coordinates: bool = False) → Condition

Finds vertices for which there is no coincident vertex and/or edge in nearby features of a given list of other feature classes. If an optional constraint is fulfilled for a pair of features, non-coincidence of vertices is allowed for these features.

classmethod qa_vertex_coincidence_self_0(feature_class: BaseDataset, point_tolerance: float = -1, edge_tolerance: float = -1, require_vertex_on_nearby_edge: bool = True, coincidence_tolerance: float = 0, is3_d: bool = False, verify_within_feature: bool = False, z_tolerance: float = 0, z_coincidence_tolerance: float = 0, report_coordinates: bool = False) → Condition

Finds vertices for which there is no coincident vertex and/or edge in nearby features of a given feature class.

classmethod qa_vertex_coincidence_self_1(feature_classes: List[BaseDataset], point_tolerance: float = -1, edge_tolerance: float = -1, require_vertex_on_nearby_edge: bool = True, coincidence_tolerance: float = 0, is3_d: bool = False, verify_within_feature: bool = False, z_tolerance: float = 0, z_coincidence_tolerance: float = 0, report_coordinates: bool = False) → Condition

Finds vertices for which there is no coincident vertex and/or edge in nearby features of a given list of feature classes.

classmethod qa_vertex_coincidence_self_2(feature_classes: List[BaseDataset], allowed_non_coincidence_condition: str, point_tolerance: float = -1, edge_tolerance: float = -1, require_vertex_on_nearby_edge: bool = True, coincidence_tolerance: float = 0, is3_d: bool = False, verify_within_feature: bool = False, z_tolerance: float = 0, z_coincidence_tolerance: float = 0, report_coordinates: bool = False) → Condition

Finds vertices for which there is no coincident vertex and/or edge in nearby features of a given list of feature classes. If an optional constraint is fulfilled for a pair of features, non-coincidence of vertices is allowed for these features.

classmethod qa_within_box_0(feature_class: BaseDataset, x_min: float, y_min: float, x_max: float, y_max: float) → Condition

Finds features that are not fully within a specified box

classmethod qa_within_box_1(feature_class: BaseDataset, x_min: float, y_min: float, x_max: float, y_max: float, report_only_outside_parts: bool) → Condition

Finds features that are not fully within a specified box

classmethod qa_within_z_range_0(feature_class: BaseDataset, minimum_z_value: float, maximum_z_value: float) → Condition

Finds features with Z values outside of a defined range.

• Supported for points, lines, polygons, multipoints and multipatches.

• For lines and polygons, individual errors are reported for consecutive segments (or parts of segments) exceeding the same boundary of the Z range.

• For multipoints and multipatches, one error is reported for all points exceeding the same boundary of the Z range.

classmethod qa_within_z_range_1(feature_class: BaseDataset, minimum_z_value: float, maximum_z_value: float, allowed_z_values: List[float]) → Condition

Finds features with Z values outside of a defined range, and allowing for special values outside the defined range (e.g. -9999).

• Supported for points, lines, polygons, multipoints and multipatches.

• For lines and polygons, individual errors are reported for consecutive segments (or parts of segments) exceeding the same boundary of the Z range.

• For multipoints and multipatches, one error is reported for all points exceeding the same boundary of the Z range.

classmethod qa_z_difference_other_0(feature_class: BaseDataset, related_class: BaseDataset, limit: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, relevant_relation_condition: Optional[str] = None, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None, use_distance_from_reference_ring_plane: bool = False, reference_ring_plane_coplanarity_tolerance: float = 0, ignore_non_coplanar_reference_rings: bool = False) → Condition

Finds features where the Z difference to features from another feature class is less than ‘limit’

classmethod qa_z_difference_other_1(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], limit: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, relevant_relation_condition: Optional[str] = None, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None, use_distance_from_reference_ring_plane: bool = False, reference_ring_plane_coplanarity_tolerance: float = 0, ignore_non_coplanar_reference_rings: bool = False) → Condition

Finds features where the Z difference to features from a list of other feature classes is less than ‘limit’

classmethod qa_z_difference_other_2(feature_class: BaseDataset, related_class: BaseDataset, minimum_z_difference: float, maximum_z_difference: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, relevant_relation_condition: Optional[str] = None, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None, use_distance_from_reference_ring_plane: bool = False, reference_ring_plane_coplanarity_tolerance: float = 0, ignore_non_coplanar_reference_rings: bool = False) → Condition

Finds features where the Z difference to another feature is not between ‘minimumZDifference’ and ‘maximumZDifference’

classmethod qa_z_difference_other_3(feature_classes: List[BaseDataset], related_classes: List[BaseDataset], minimum_z_difference: float, maximum_z_difference: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, relevant_relation_condition: Optional[str] = None, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None, use_distance_from_reference_ring_plane: bool = False, reference_ring_plane_coplanarity_tolerance: float = 0, ignore_non_coplanar_reference_rings: bool = False) → Condition

Finds features where the Z difference to features from a list of other feature classes is not between ‘minimumZDifference’ and ‘maximumZDifference’

classmethod qa_z_difference_self_0(feature_class: BaseDataset, limit: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds features where the Z difference to another feature is less than ‘limit’

classmethod qa_z_difference_self_1(feature_classes: List[BaseDataset], limit: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds features where the Z difference to another feature within a list of feature classes is less than ‘limit’

classmethod qa_z_difference_self_2(feature_class: BaseDataset, minimum_z_difference: float, maximum_z_difference: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds features where the Z difference to another feature is not between ‘minimumZDifference’ and ‘maximumZDifference’

classmethod qa_z_difference_self_3(feature_classes: List[BaseDataset], minimum_z_difference: float, maximum_z_difference: float, z_comparison_method: ZComparisonMethod, z_relation_constraint: str, minimum_z_difference_expression: Optional[str] = None, maximum_z_difference_expression: Optional[str] = None) → Condition

Finds features where the Z difference to another feature within a list of feature classes is not between ‘minimumZDifference’ and ‘maximumZDifference’

transformers module

class prosuite.factories.transformers.Transformers

Bases: object

classmethod not_yet_implemented(feature_class: BaseDataset, tolerance: float) → TransformedDataset

Stay tuned

enums module

class prosuite.factories.enums.AllowedEndpointInteriorIntersections(value)

Bases: Enum

An enumeration.

All = 0

NoValue = 2

Vertex = 1

class prosuite.factories.enums.AllowedLineInteriorIntersections(value)

Bases: Enum

An enumeration.

AtVertexOnBothLines = 1

NoValue = 0

class prosuite.factories.enums.AngleUnit(value)

Bases: Enum

An enumeration.

Degree = 1

Radiant = 0

class prosuite.factories.enums.BoundaryLoopAreaRelation(value)

Bases: Enum

An enumeration.

IgnoreLarger = 1

IgnoreSmallerOrEqual = 0

class prosuite.factories.enums.BoundaryLoopErrorGeometry(value)

Bases: Enum

An enumeration.

LoopPolygon = 0

LoopStartPoint = 1

class prosuite.factories.enums.ConnectionMode(value)

Bases: Enum

An enumeration.

EndpointOnEndpoint = 0

EndpointOnVertex = 1

VertexOnVertex = 2

class prosuite.factories.enums.ExpectedCase(value)

Bases: Enum

An enumeration.

AllLower = 2

AllUpper = 1

Any = 0

Mixed = 3

NotAllLower = 5

NotAllUpper = 4

class prosuite.factories.enums.ExpectedStringDifference(value)

Bases: Enum

An enumeration.

Any = 0

CaseInsensitiveDifference = 2

CaseSensitiveDifference = 1

class prosuite.factories.enums.FieldListType(value)

Bases: Enum

An enumeration.

IgnoredFields = 0

RelevantFields = 1

class prosuite.factories.enums.GeometryComponent(value)

Bases: Enum

An enumeration.

Boundary = 1

Centroid = 6

EntireGeometry = 0

InteriorVertices = 8

LabelPoint = 7

LineEndPoint = 5

LineEndPoints = 3

LineStartPoint = 4

Vertices = 2

class prosuite.factories.enums.GroupErrorReporting(value)

Bases: Enum

An enumeration.

CombineParts = 4

ReferToFirstPart = 1

ShortestGaps = 2

class prosuite.factories.enums.InnerRingHandling(value)

Bases: Enum

An enumeration.

IgnoreHorizontalInnerRings = 2

IgnoreInnerRings = 1

NoValue = 0

class prosuite.factories.enums.JoinType(value)

Bases: Enum

An enumeration.

InnerJoin = 1

LeftJoin = 2

RightJoin = 3

class prosuite.factories.enums.LineCapStyle(value)

Bases: Enum

An enumeration.

Butt = 1

Round = 0

class prosuite.factories.enums.LineFieldValuesConstraint(value)

Bases: Enum

An enumeration.

AllEqual = 1

AllEqualOrValidPointExists = 2

AtLeastTwoDistinctValuesIfValidPointExists = 3

NoConstraint = 0

UniqueOrValidPointExists = 4

class prosuite.factories.enums.LineMSource(value)

Bases: Enum

An enumeration.

Nearest = 0

VertexPreferred = 1

VertexRequired = 2

class prosuite.factories.enums.MonotonicityDirection(value)

Bases: Enum

An enumeration.

Any = 0

Decreasing = 2

Increasing = 1

class prosuite.factories.enums.NonLinearSegmentType(value)

Bases: Enum

An enumeration.

Bezier = 0

CircularArc = 1

EllipticArc = 2

class prosuite.factories.enums.OrphanErrorType(value)

Bases: Enum

An enumeration.

Both = 1

EndPointWithoutPoint = 3

OrphanedPoint = 2

class prosuite.factories.enums.PointFieldValuesConstraint(value)

Bases: Enum

An enumeration.

AllEqualAndMatchAnyLineValue = 1

AllEqualAndMatchMostFrequentLineValue = 2

NoConstraint = 0

class prosuite.factories.enums.PolylineUsage(value)

Bases: Enum

An enumeration.

AsIs = 0

AsPolygonIfClosedElseAsPolyline = 1

AsPolygonIfClosedElseIgnore = 2

AsPolygonIfClosedElseReportIssue = 3

class prosuite.factories.enums.ShapeAllowed(value)

Bases: Enum

An enumeration.

All = 7

Branches = 2

Cycles = 1

CyclesAndBranches = 3

InsideBranches = 4

NoValue = 0

class prosuite.factories.enums.UniqueStringsConstraint(value)

Bases: Enum

An enumeration.

NoValue = 0

UniqueAnyCase = 2

UniqueExactCase = 1

class prosuite.factories.enums.ZComparisonMethod(value)

Bases: Enum

An enumeration.

BoundingBox = 0

IntersectionPoints = 1

class prosuite.factories.enums.esriFieldType(value)

Bases: Enum

An enumeration.

esriFieldTypeBigInteger = 13

esriFieldTypeBlob = 8

esriFieldTypeDate = 5

esriFieldTypeDouble = 3

esriFieldTypeGUID = 10

esriFieldTypeGeometry = 7

esriFieldTypeGlobalID = 11

esriFieldTypeInteger = 1

esriFieldTypeOID = 6

esriFieldTypeRaster = 9

esriFieldTypeSingle = 2

esriFieldTypeSmallInteger = 0

esriFieldTypeString = 4

esriFieldTypeXML = 12