from tests.strategies import (coordinates_strategies, coordinates_to_multipolygons, coordinates_to_points, coordinates_to_polygons, invalid_multipolygons) from tests.utils import (cleave_in_tuples, to_pairs, to_triplets) multipolygons = coordinates_strategies.flatmap(coordinates_to_multipolygons) polygons = coordinates_strategies.flatmap(coordinates_to_polygons) invalid_multipolygons = invalid_multipolygons multipolygons_strategies = ( coordinates_strategies.map(coordinates_to_multipolygons)) multipolygons_pairs = multipolygons_strategies.flatmap(to_pairs) multipolygons_triplets = multipolygons_strategies.flatmap(to_triplets) multipolygons_with_points = (coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_multipolygons, coordinates_to_points)))
empty_compounds_factory = to_constant(empty_compounds) non_empty_compounds_factories = (strategies.sampled_from([ coordinates_to_multipoints, coordinates_to_segments, coordinates_to_multisegments, coordinates_to_contours, coordinates_to_polygons, coordinates_to_multipolygons, coordinates_to_mixes ])) non_empty_geometries_factories = (strategies.just(coordinates_to_points) | non_empty_compounds_factories) geometries_factories = (strategies.just(empty_compounds_factory) | non_empty_geometries_factories) geometries_strategies = strategies.builds(call, geometries_factories, coordinates_strategies) geometries = geometries_strategies.flatmap(identity) rational_geometries_with_non_zero_coordinates_pairs = strategies.builds( call, geometries_factories.map(lambda factory: cleave_in_tuples( factory, to_non_zero_coordinates, to_non_zero_coordinates)), rational_coordinates_strategies).flatmap(identity) empty_compounds_with_coordinates_pairs = (coordinates_strategies.flatmap( cleave_in_tuples(empty_compounds_factory, identity, identity))) geometries_with_coordinates_pairs = strategies.builds( call, geometries_factories.map(lambda factory: cleave_in_tuples( factory, to_zero_coordinates, identity)) | geometries_factories.map(lambda factory: cleave_in_tuples( factory, identity, to_zero_coordinates)) | geometries_factories.map( lambda factory: cleave_in_tuples(factory, identity, identity)), coordinates_strategies).flatmap(identity) rational_geometries_with_points = ((strategies.builds( call, geometries_factories.map(
segment.start.translate(scale * (segment.start.x - segment.end.x), scale * (segment.start.y - segment.end.y)), segment.end) invalid_mixes = ( shaped_geometries.flatmap(shaped_to_invalid_mix) | strategies.builds(Mix, empty_geometries | multipoints, empty_geometries, empty_geometries) | strategies.builds(Mix, empty_geometries, empty_geometries | linear_geometries, empty_geometries) | strategies.builds(Mix, empty_geometries, empty_geometries, empty_geometries | shaped_geometries) | strategies.builds(Mix, invalid_multipoints, empty_geometries | linear_geometries, shaped_geometries) | strategies.builds(Mix, invalid_multipoints, linear_geometries, empty_geometries | shaped_geometries) | strategies.builds(Mix, empty_geometries | multipoints, invalid_linear_geometries, shaped_geometries) | strategies.builds(Mix, multipoints, invalid_linear_geometries, empty_geometries | shaped_geometries) | strategies.builds(Mix, multipoints, empty_geometries | linear_geometries, invalid_shaped_geometries) | strategies.builds(Mix, empty_geometries | multipoints, linear_geometries, invalid_shaped_geometries)) mixes_with_points = (coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_mixes, coordinates_to_points))) mixes_strategies = coordinates_strategies.map(coordinates_to_mixes) mixes_pairs = mixes_strategies.flatmap(to_pairs) mixes_triplets = mixes_strategies.flatmap(to_triplets)
from tests.strategies import (coordinates_strategies, coordinates_to_points, coordinates_to_segments, invalid_segments, rational_coordinates_strategies) from tests.utils import (cleave_in_tuples, to_pairs, to_triplets) rational_segments = ( rational_coordinates_strategies.flatmap(coordinates_to_segments)) segments = coordinates_strategies.flatmap(coordinates_to_segments) invalid_segments = invalid_segments segments_strategies = coordinates_strategies.map(coordinates_to_segments) segments_with_points = (coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_segments, coordinates_to_points))) segments_pairs = segments_strategies.flatmap(to_pairs) segments_triplets = segments_strategies.flatmap(to_triplets)
from hypothesis import strategies from tests.strategies import (coordinates_strategies, coordinates_to_linear_geometries, coordinates_to_points, rational_coordinates_strategies, rational_cosines_sines) from tests.utils import (cleave_in_tuples, identity) linear_geometries = coordinates_strategies.flatmap( coordinates_to_linear_geometries) rational_linear_geometries_with_coordinates_pairs = ( rational_coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_linear_geometries, identity, identity))) rational_linear_geometries_points_with_cosines_sines = (strategies.tuples( (rational_coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_linear_geometries, coordinates_to_points))), rational_cosines_sines))
.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, identity)), rational_coordinates_strategies) .flatmap(identity))) rational_non_empty_compounds = ( strategies.builds(call, non_empty_compounds_factories, rational_coordinates_strategies).flatmap(identity)) rational_non_empty_compounds_with_cosines_sines = strategies.tuples( rational_non_empty_compounds, rational_cosines_sines) rational_non_empty_compounds_with_points = ( (strategies.builds(call, non_empty_compounds_factories .map(lambda factory : cleave_in_tuples(factory, coordinates_to_points)), rational_coordinates_strategies) .flatmap(identity)))
from typing import Tuple from hypothesis import strategies from gon.base import (Contour, Point) from gon.hints import Scalar from tests.strategies import (coordinates_strategies, coordinates_to_contours, coordinates_to_points, invalid_contours, to_non_zero_coordinates, to_zero_coordinates) from tests.utils import (Strategy, cleave_in_tuples, to_pairs, to_triplets) contours = coordinates_strategies.flatmap(coordinates_to_contours) def coordinates_to_contours_with_points( coordinates: Strategy[Scalar]) -> Strategy[Tuple[Contour, Point]]: return strategies.tuples(coordinates_to_contours(coordinates), coordinates_to_points(coordinates)) contours_with_points = ( coordinates_strategies.flatmap(coordinates_to_contours_with_points)) invalid_contours = invalid_contours contours_with_zero_non_zero_coordinates = coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_contours, to_zero_coordinates, to_non_zero_coordinates)) contours_strategies = coordinates_strategies.map(coordinates_to_contours) contours_pairs = contours_strategies.flatmap(to_pairs) contours_triplets = contours_strategies.flatmap(to_triplets)
from hypothesis import strategies from gon.hints import Scalar from tests.strategies import (coordinates_strategies, coordinates_to_points, coordinates_to_shaped_geometries, rational_coordinates_strategies, rational_cosines_sines) from tests.utils import (Strategy, cleave_in_tuples, identity) rational_shaped_geometries = ( rational_coordinates_strategies.flatmap(coordinates_to_shaped_geometries)) shaped_geometries = ( coordinates_strategies.flatmap(coordinates_to_shaped_geometries)) rational_shaped_geometries_with_coordinates_pairs = ( rational_coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_shaped_geometries, identity, identity))) def coordinates_to_non_zero_coordinates( coordinates: Strategy[Scalar]) -> Strategy[Scalar]: return coordinates.filter(bool) rational_shaped_geometries_with_non_zero_coordinates_pairs = ( rational_coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_shaped_geometries, coordinates_to_non_zero_coordinates, coordinates_to_non_zero_coordinates))) rational_shaped_geometries_points_with_cosines_sines = (strategies.tuples( (rational_coordinates_strategies.flatmap( cleave_in_tuples(coordinates_to_shaped_geometries,
scalars: Strategy[Scalar]) -> Strategy[PortedOperation]: non_empty_polygons = scalars_to_ported_polygons(scalars, min_size=1) return strategies.builds(PortedOperation, non_empty_polygons, non_empty_polygons, operations_types) def scalars_to_operations( scalars: Strategy[Scalar]) -> Strategy[PortedOperation]: return (scalars_to_trivial_operations(scalars) | scalars_to_non_trivial_operations(scalars)) operations_strategies = scalars_strategies.map(scalars_to_operations) operations = operations_strategies.flatmap(identity) operations_with_sweep_events = scalars_strategies.flatmap( cleave_in_tuples(scalars_to_operations, scalars_to_ported_sweep_events)) operations_with_double_nested_sweep_events_and_points = ( scalars_strategies.flatmap( cleave_in_tuples( scalars_to_operations, compose(to_double_nested_sweep_events, scalars_to_nested_ported_sweep_events), scalars_to_ported_points))) operations_with_sweep_events_and_maybe_sweep_events = ( scalars_strategies.flatmap( cleave_in_tuples( scalars_to_operations, scalars_to_ported_sweep_events, compose(to_maybe, scalars_to_nested_ported_sweep_events)))) operations_pairs = operations_strategies.flatmap(to_pairs) operations_triplets = operations_strategies.flatmap(to_triplets)
from tests.port_tests.utils import (ported_edges_types, ported_polygons_types) from tests.strategies import (booleans, non_negative_integers, scalars_strategies) from tests.utils import (cleave_in_tuples, identity, to_maybe, to_pairs, to_triplets) booleans = booleans non_negative_integers = non_negative_integers polygons_types = ported_polygons_types edges_types = ported_edges_types points = scalars_strategies.flatmap(scalars_to_ported_points) leaf_sweep_events = (scalars_strategies.flatmap( partial(scalars_to_plain_ported_sweep_events, children=strategies.none()))) leaf_sweep_events_with_points = scalars_strategies.flatmap( cleave_in_tuples( partial(scalars_to_plain_ported_sweep_events, children=strategies.none()), scalars_to_ported_points)) acyclic_sweep_events = ( scalars_strategies.flatmap(scalars_to_acyclic_ported_sweep_events)) sweep_events_strategies = ( scalars_strategies.map(scalars_to_ported_sweep_events)) sweep_events = sweep_events_strategies.flatmap(identity) sweep_events_pairs = sweep_events_strategies.flatmap(to_pairs) sweep_events_triplets = sweep_events_strategies.flatmap(to_triplets) nested_sweep_events = ( scalars_strategies.flatmap(scalars_to_nested_ported_sweep_events)) nested_sweep_events_with_points = scalars_strategies.flatmap( cleave_in_tuples(scalars_to_nested_ported_sweep_events, scalars_to_ported_points)) maybe_sweep_events = to_maybe(sweep_events)
Polygon, Segment, Strategy, cleave_in_tuples, left_scale_segment, right_scale_segment, sub_lists, to_multipolygon_edges, to_pairs, to_polygon_edges, to_triplets) points = coordinates_strategies.flatmap(planar.points) segments = coordinates_strategies.flatmap(planar.segments) segments_with_points = (coordinates_strategies .flatmap(cleave_in_tuples(planar.segments, planar.points))) segments_strategies = coordinates_strategies.map(planar.segments) segments_pairs = segments_strategies.flatmap(to_pairs) multisegments = coordinates_strategies.flatmap(planar.multisegments) multisegments_with_points = (coordinates_strategies .flatmap(cleave_in_tuples(planar.multisegments, planar.points))) multisegments_with_segments = (coordinates_strategies .flatmap(cleave_in_tuples(planar.multisegments, planar.segments))) to_size_three_or_more_multisegments = partial(planar.multisegments, min_size=3) size_three_or_more_multisegments_with_segments = ( (coordinates_strategies .flatmap(cleave_in_tuples(to_size_three_or_more_multisegments, planar.segments))))