def to_boxes(scalars: Strategy[Scalar]) -> Strategy[Box]: return (to_pairs(strategies.lists(scalars, min_size=2, max_size=2, unique=True) .map(sorted)) .map(pack(add)) .map(pack(Box)))
def to_boxes(context: Context, coordinates: Strategy[Scalar]) -> Strategy[Box]: return (to_pairs(strategies.lists(coordinates, unique=True, min_size=2, max_size=2) .map(sorted)) .map(pack(add)) .map(pack(context.box_cls)))
def to_crossing_segments_pairs(context: Context, coordinates: Strategy[Scalar] ) -> Strategy[Tuple[Segment, Segment]]: segment_factory = pack(context.segment_cls) return (to_crossing_segments_pairs_endpoints(context, coordinates) .map(cleave(compose(segment_factory, itemgetter(0, 1)), compose(segment_factory, itemgetter(2, 3)))))
def coordinates_to_ported_points_pairs_edges_pairs( coordinates: Strategy[Coordinate] ) -> Strategy[Tuple[PortedPoint, PortedPoint, PortedEdge, PortedEdge]]: edges = coordinates_to_ported_edges(coordinates) return (strategies.tuples( coordinates_to_sorted_ported_points_pairs(coordinates), strategies.tuples(edges, edges)) .map(pack(add)))
def to_repeated_patterns(strategy: Strategy[str]) -> Strategy[str]: counts = strategies.integers(0, 10) templates = (strategies.sampled_from(['{}?', '{}*', '{}+']) | counts.map('{{}}{{{{{},}}}}'.format) | counts.map('{{}}{{{{{}}}}}'.format) | (strategies.tuples(counts, counts).map(sort_pair).map( pack('{{}}{{{{{},{}}}}}'.format)))) def apply_template(template: str) -> Strategy[str]: return strategy.map(template.format) return templates.flatmap(apply_template)
from paradigm import catalog from tests.strategies import (identifiers, to_homogeneous_tuples) from tests.utils import pack objects_paths = to_homogeneous_tuples(identifiers).map(pack(catalog.Path))
def points_to_degenerate_segments( points: Strategy[Point]) -> Strategy[Segment]: return (points.map(partial(repeat, times=2)).map(pack(Segment)))
from hypothesis import strategies from tests.integration_tests.utils import (to_bound_with_ported_boxes_pair, to_bound_with_ported_points_pair) from tests.strategies import coordinates from tests.utils import (pack, to_pairs) points_pairs = strategies.builds(to_bound_with_ported_points_pair, coordinates, coordinates) points_pairs_pairs = to_pairs(points_pairs) boxes_pairs = points_pairs_pairs.map(pack(to_bound_with_ported_boxes_pair))
from hypothesis import strategies from tests.utils import (BoundSet, pack) objects = strategies.integers() objects_lists = strategies.lists(objects) sets = objects_lists.map(pack(BoundSet))
def coordinates_to_segments( coordinates: Strategy[Coordinate]) -> Strategy[Segment]: return (to_pairs(coordinates_to_points(coordinates)).filter(pack(ne)).map( pack(Segment)))
from hypothesis import strategies from tests.utils import (BoundVector, pack) objects = strategies.integers() objects_lists = strategies.lists(objects) vectors = objects_lists.map(pack(BoundVector))
multipoints_sizes_pairs = to_sizes_pairs(MIN_MULTIPOINT_SIZE) multipolygons_sizes_pairs = to_sizes_pairs(MIN_MULTIPOLYGON_SIZE, 5) multisegments_sizes_pairs = to_sizes_pairs(MIN_MULTISEGMENT_SIZE) polygon_holes_sizes_pairs = to_sizes_pairs(0, 5) non_valid_concave_contours_sizes_pairs = to_non_valid_sizes_pairs( MinContourSize.CONCAVE) non_valid_convex_contours_sizes_pairs = to_non_valid_sizes_pairs( MinContourSize.CONVEX) invalid_concave_contours_sizes_pairs = to_invalid_sizes_pairs( MinContourSize.CONCAVE) invalid_convex_contours_sizes_pairs = to_invalid_sizes_pairs( MinContourSize.CONVEX) invalid_mix_components_sizes_pairs_triplets = ((strategies.permutations( [to_sizes_pairs(0), strategies.just((0, 0)), strategies.just((0, 0))]).flatmap(pack(strategies.tuples)))) invalid_multicontours_sizes_pairs = to_invalid_sizes_pairs( MIN_MULTICONTOUR_SIZE) invalid_polygon_holes_sizes_pairs = to_invalid_sizes_pairs(0) invalid_multipoints_sizes_pairs = to_invalid_sizes_pairs(MIN_MULTIPOINT_SIZE) invalid_multipolygons_sizes_pairs = to_invalid_sizes_pairs( MIN_MULTIPOLYGON_SIZE) invalid_mix_points_sizes_pairs = to_invalid_sizes_pairs(0) invalid_mix_polygons_sizes_pairs = to_invalid_sizes_pairs(0) invalid_mix_segments_sizes_pairs = to_invalid_sizes_pairs(0) invalid_multisegments_sizes_pairs = to_invalid_sizes_pairs( MIN_MULTISEGMENT_SIZE) def to_coordinates_strategies_with_limits_and_types( type_: Type[Scalar]
def coordinates_to_ported_y_nodes(coordinates: Strategy[Coordinate] ) -> Strategy[PortedYNode]: return (coordinates_to_ported_edges_with_nodes_pairs(coordinates) .map(pack(PortedYNode)))
def coordinates_to_ported_x_nodes(coordinates: Strategy[Coordinate] ) -> Strategy[PortedXNode]: return (coordinates_to_ported_points_with_nodes_pairs(coordinates) .map(pack(PortedXNode)))
def coordinates_to_ported_trapezoids(coordinates: Strategy[Coordinate] ) -> Strategy[PortedTrapezoid]: return (coordinates_to_ported_points_pairs_edges_pairs(coordinates) .map(pack(PortedTrapezoid)))
def coordinates_to_ported_edges(coordinates: Strategy[Coordinate] ) -> Strategy[PortedEdge]: return (coordinates_to_sorted_ported_points_pairs(coordinates) .map(pack(PortedEdge)))
def to_segments(scalar: Strategy[Scalar]) -> Strategy[Segment]: return (strategies.lists(to_points(scalar), min_size=2, max_size=2, unique=True) .map(pack(Segment)))
from operator import ne from _seidel import (Edge, Point) from hypothesis import strategies from tests.strategies import (floats, to_pairs) from tests.utils import (pack, sort_points) points = strategies.builds(Point, floats, floats) sorted_points = to_pairs(points).filter(pack(ne)).map(sort_points) edges = sorted_points.map(pack(Edge))
from functools import partial from hypothesis import strategies from tests.port_tests.factories import scalars_to_ported_polygons from tests.port_tests.hints import PortedPolygon from tests.port_tests.utils import (ported_operations_types, to_non_overlapping_ported_polygons_pair) from tests.strategies import scalars_strategies from tests.utils import (identity, pack, to_pairs) operations_types = ported_operations_types empty_polygons = strategies.builds(PortedPolygon, strategies.builds(list)) polygons = scalars_strategies.flatmap(scalars_to_ported_polygons) non_empty_polygons_strategies = (scalars_strategies.map( partial(scalars_to_ported_polygons, min_size=1))) non_empty_polygons = non_empty_polygons_strategies.flatmap(identity) polygons_pairs = (strategies.tuples(empty_polygons, non_empty_polygons) | strategies.tuples(non_empty_polygons, empty_polygons) | non_empty_polygons_strategies.flatmap(to_pairs).map( pack(to_non_overlapping_ported_polygons_pair)))
non_empty_compounds_factories = ( strategies.sampled_from([coordinates_to_multipoints, coordinates_to_segments]) | indexables_factories) non_empty_geometries_factories = (strategies.just(coordinates_to_points) | non_empty_compounds_factories) compounds_factories = (strategies.just(to_constant(empty_compounds)) | non_empty_compounds_factories) indexables = (strategies.builds(call, indexables_factories, coordinates_strategies) .flatmap(identity)) indexables_with_non_empty_geometries = strategies.builds( call, (strategies.tuples(indexables_factories, non_empty_geometries_factories) .map(pack(cleave_in_tuples))), coordinates_strategies).flatmap(identity) non_empty_compounds_strategies = strategies.builds( call, non_empty_compounds_factories, coordinates_strategies) non_empty_compounds = non_empty_compounds_strategies.flatmap(identity) non_empty_compounds_pairs = non_empty_compounds_strategies.flatmap(to_pairs) compounds = (strategies.builds(call, compounds_factories, coordinates_strategies) .flatmap(identity)) rational_compounds = (strategies.builds(call, compounds_factories, rational_coordinates_strategies) .flatmap(identity)) rational_non_empty_compounds_with_coordinates_pairs = ( (strategies.builds(call, non_empty_compounds_factories .map(lambda factory: cleave_in_tuples(factory, identity,
from hypothesis import strategies from tests.utils import (PortedSet, pack) objects = strategies.integers() objects_lists = strategies.lists(objects) sets = objects_lists.map(pack(PortedSet))
def to_valid_length(parts: List[str], *, limit: int = 255) -> List[str]: result = [] parts = iter(parts) while limit > 0: try: part = next(parts) except StopIteration: break part = part[:limit] result.append(part) limit -= len(part) + len(os.sep) return result paths = strategies.lists(identifiers).map(to_valid_length).map(pack(Path)) def is_valid_source(string: str) -> bool: try: ast.parse(string) except (ValueError, SyntaxError): return False else: return True keywords_lists = strategies.lists(strategies.sampled_from(keyword.kwlist)) invalid_source_lines = ((keywords_lists.map(' '.join) | keywords_lists.map(';'.join)).filter( negate(is_valid_source)))
from hypothesis import strategies from tests.strategies import (floats, to_bound_with_ported_edges_pair, to_bound_with_ported_points_pair, to_pairs) from tests.utils import (are_endpoints_non_degenerate, pack, sort_endpoints) points_pairs = strategies.builds(to_bound_with_ported_points_pair, floats, floats) sorted_points_pairs_pairs = (to_pairs(points_pairs).filter( are_endpoints_non_degenerate).map(sort_endpoints)) edges_pairs = (sorted_points_pairs_pairs.map( pack(to_bound_with_ported_edges_pair)))
from operator import add from hypothesis import strategies from tests.strategies import (floats, to_bound_with_ported_edges_pair, to_bound_with_ported_leaves_pair, to_bound_with_ported_points_pair, to_bound_with_ported_trapezoids_pair, to_pairs) from tests.utils import (are_endpoints_non_degenerate, pack, sort_endpoints) points_pairs = strategies.builds(to_bound_with_ported_points_pair, floats, floats) sorted_points_pairs_pairs = (to_pairs(points_pairs) .filter(are_endpoints_non_degenerate) .map(sort_endpoints)) edges_pairs = (sorted_points_pairs_pairs .map(pack(to_bound_with_ported_edges_pair))) trapezoids_pairs = (strategies.tuples(sorted_points_pairs_pairs, to_pairs(edges_pairs)) .map(pack(add)) .map(pack(to_bound_with_ported_trapezoids_pair))) leaves_pairs = trapezoids_pairs.map(pack(to_bound_with_ported_leaves_pair))
from operator import add from hypothesis import strategies from tests.strategies import (floats, to_bound_with_ported_edges_pair, to_bound_with_ported_points_pair, to_bound_with_ported_trapezoids_pair, to_pairs) from tests.utils import (are_endpoints_non_degenerate, pack, sort_endpoints) points_pairs = strategies.builds(to_bound_with_ported_points_pair, floats, floats) sorted_points_pairs_pairs = (to_pairs(points_pairs).filter( are_endpoints_non_degenerate).map(sort_endpoints)) edges_pairs = (sorted_points_pairs_pairs.map( pack(to_bound_with_ported_edges_pair))) trapezoids_pairs = (strategies.tuples( sorted_points_pairs_pairs, to_pairs(edges_pairs)).map(pack(add)).map( pack(to_bound_with_ported_trapezoids_pair)))
def to_plain_signatures( *, parameters_names: Strategy[str] = identifiers, parameters_kinds: Strategy[Parameter.Kind], parameters_has_default_flags: Strategy[bool] = strategies.booleans(), min_size: int = 0, max_size: int) -> Strategy[Base]: if min_size < 0: raise ValueError('Min size ' 'should not be negative, ' 'but found {min_size}.'.format(min_size=min_size)) if min_size > max_size: raise ValueError('Min size ' 'should not be greater ' 'than max size, ' 'but found {min_size} > {max_size}.'.format( min_size=min_size, max_size=max_size)) empty = strategies.builds(Plain) if max_size == 0: return empty @strategies.composite def extend( draw: Map[Strategy[Domain], Domain], base: Strategy[Tuple[Parameter, ...]]) -> Strategy[Tuple[Parameter, ...]]: precursors = draw(base) precursors_names = set(map(attrgetter('name'), precursors)) precursors_kinds = to_parameters_by_kind(precursors) last_precursor = precursors[-1] def is_kind_valid(parameter: Parameter) -> bool: if parameter.kind not in (Parameter.positionals_kinds | Parameter.keywords_kinds): return not precursors_kinds[parameter.kind] return True def normalize(parameter: Parameter) -> Parameter: if parameter.kind in Parameter.positionals_kinds: if last_precursor.has_default and not parameter.has_default: return Parameter(name=parameter.name, kind=parameter.kind, has_default=True) return parameter follower = draw( to_parameters( names=identifiers.filter(negate( precursors_names.__contains__)), kinds=(parameters_kinds.filter( partial(le, max(precursors_kinds)))), has_default_flags=parameters_has_default_flags).filter( is_kind_valid).map(normalize)) return precursors + (follower, ) base_parameters = to_parameters( names=parameters_names, kinds=parameters_kinds, has_default_flags=parameters_has_default_flags) non_empty = (strategies.recursive(strategies.tuples(base_parameters), extend, max_leaves=max_size).map(pack(Plain))) if min_size == 0: return empty | non_empty return non_empty
def scalars_to_segments(scalars: Strategy[Scalar]) -> Strategy[Segment]: return (to_pairs(scalars_to_points(scalars)).filter(pack(ne)).map( pack(Segment)))
def to_overloaded_signatures(bases: Strategy[Base], *, min_size: int = 2, max_size: int = None) -> Strategy[Base]: return (strategies.lists(bases, min_size=min_size, max_size=max_size).map(pack(Overloaded)))
from operator import (add, ne) from _seidel import (Edge, Leaf, Node, Point, Trapezoid, XNode, YNode) from hypothesis import strategies from tests.strategies import (floats, recursive, to_pairs) from tests.utils import (Strategy, pack, sort_points) points = strategies.builds(Point, floats, floats) sorted_points_pairs = to_pairs(points).filter(pack(ne)).map(sort_points) edges = sorted_points_pairs.map(pack(Edge)) trapezoids = (strategies.tuples(sorted_points_pairs, to_pairs(edges)).map( pack(add)).map(pack(Trapezoid))) leaves = trapezoids.map(Leaf) def to_nodes(nodes: Strategy[Node]) -> Strategy[Node]: return to_x_nodes(nodes) | to_y_nodes(nodes) def to_x_nodes(nodes: Strategy[Node]) -> Strategy[YNode]: return strategies.builds(XNode, points, nodes, nodes) def to_y_nodes(nodes: Strategy[Node]) -> Strategy[YNode]: return strategies.builds(YNode, edges, nodes, nodes) nodes = recursive(leaves, to_nodes) x_nodes = to_x_nodes(nodes)
unrepeated_patterns = strategies.recursive( exact_patterns | characters_lists | excluded_characters_lists, extend_patterns) def to_repeated_patterns(strategy: Strategy[str]) -> Strategy[str]: counts = strategies.integers(0, 10) templates = (strategies.sampled_from(['{}?', '{}*', '{}+']) | counts.map('{{}}{{{{{},}}}}'.format) | counts.map('{{}}{{{{{}}}}}'.format) | (strategies.tuples(counts, counts).map(sort_pair).map( pack('{{}}{{{{{},{}}}}}'.format)))) def apply_template(template: str) -> Strategy[str]: return strategy.map(template.format) return templates.flatmap(apply_template) patterns = (unrepeated_patterns | to_repeated_patterns(unrepeated_patterns.filter(bool))) patterns |= strategies.tuples(patterns, patterns).map(pack('{}|{}'.format)) captures_names = strategies.text(strategies.sampled_from(string.ascii_letters), min_size=1) patterns |= (strategies.tuples(captures_names, patterns).map(pack('(?P<{}>{})'.format))) patterns |= patterns.map('^{}'.format) patterns |= patterns.map('{}$'.format)