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))))
