Commita331d3e

authored

Merge pull request#3768 from tybug/namedtuple-generic

2 parentsb4ddfd1 +0d0ff88 commita331d3eCopy full SHA for a331d3e

File tree

+58

-5

lines changed

+58

-5

lines changed

Lines changed: 1 addition & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -108,6 +108,7 @@ their individual contributions.`
`108`	`108`	* `Lampros Mountrakis<https://www.github.com/lmount>`_
`109`	`109`	* `Lea Provenzano<https://github.com/leaprovenzano>`_
`110`	`110`	* `Lee Begg<https://www.github.com/llnz2>`_
	`111`	+* `Liam DeVoe<https://github.com/tybug>`_
`111`	`112`	* `Libor Martínek<https://github.com/bibajz>`_
`112`	`113`	* `Lisa Goeller<https://www.github.com/lgoeller>`_
`113`	`114`	* `Louis Taylor<https://github.com/kragniz>`_

Lines changed: 5 additions & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,5 @@`
	`1`	`+RELEASE_TYPE: patch`
	`2`	`+`
	`3`	+This patch improves:func:`~hypothesis.strategies.register_type_strategy` when used with ``tuple`` subclasses,
	`4`	+by preventing them from being interpreted as generic and provided to strategies like ``st.from_type(Sequence[int])``
	`5`	+(:issue:`3767`).

Lines changed: 11 additions & 4 deletions

Original file line number	Diff line number	Diff line change
`@@ -391,10 +391,16 @@ def from_typing_type(thing):`
`391`	`391`	`fork,vin_global_type_lookup.items()`
`392`	`392`	`ifis_generic_type(k)andtry_issubclass(k,thing)`
`393`	`393`	`}`
`394`		`-# Drop some unusual cases for simplicity`
`395`		`-forweirdin (tuple,getattr(os,"_Environ",None)):`
`396`		`-iflen(mapping)>1:`
`397`		`-mapping.pop(weird,None)`
	`394`	`+# Drop some unusual cases for simplicity, including tuples or its`
	`395`	`+# subclasses (e.g. namedtuple)`
	`396`	`+iflen(mapping)>1:`
	`397`	`+_Environ=getattr(os,"_Environ",None)`
	`398`	`+mapping.pop(_Environ,None)`
	`399`	`+tuple_types= [tfortinmappingifisinstance(t,type)andissubclass(t,tuple)]`
	`400`	`+iflen(mapping)>len(tuple_types):`
	`401`	`+fortuple_typeintuple_types:`
	`402`	`+mapping.pop(tuple_type)`
	`403`	`+`
`398`	`404`	`# After we drop Python 3.8 and can rely on having generic builtin types, we'll`
`399`	`405`	`# be able to simplify this logic by dropping the typing-module handling.`
`400`	`406`	`if {dict,set,typing.Dict,typing.Set}.intersection(mapping):`
`@@ -407,6 +413,7 @@ def from_typing_type(thing):`
`407`	`413`	`# the ghostwriter than it's worth, via undefined names in the repr.`
`408`	`414`	`mapping.pop(collections.deque,None)`
`409`	`415`	`mapping.pop(typing.Deque,None)`
	`416`	`+`
`410`	`417`	`iflen(mapping)>1:`
`411`	`418`	`# issubclass treats bytestring as a kind of sequence, which it is,`
`412`	`419`	`# but treating it as such breaks everything else when it is presumed`

Lines changed: 17 additions & 1 deletion

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,12 @@`
`36`	`36`	`fromhypothesis.strategiesimportfrom_type`
`37`	`37`	`fromhypothesis.strategies._internalimporttypes`
`38`	`38`
`39`		`-fromtests.common.debugimportassert_all_examples,find_any,minimal`
	`39`	`+fromtests.common.debugimport (`
	`40`	`+assert_all_examples,`
	`41`	`+assert_no_examples,`
	`42`	`+find_any,`
	`43`	`+minimal,`
	`44`	`+)`
`40`	`45`	`fromtests.common.utilsimportfails_with,temp_registered`
`41`	`46`
`42`	`47`	`sentinel=object()`
`@@ -1146,6 +1151,17 @@ def f(x: int):`
`1146`	`1151`	`st.builds(f).example()`
`1147`	`1152`
`1148`	`1153`
	`1154`	`+classTupleSubtype(tuple):`
	`1155`	`+pass`
	`1156`	`+`
	`1157`	`+`
	`1158`	`+deftest_tuple_subclasses_not_generic_sequences():`
	`1159`	`+# see https://github.com/HypothesisWorks/hypothesis/issues/3767.`
	`1160`	`+withtemp_registered(TupleSubtype,st.builds(TupleSubtype)):`
	`1161`	`+s=st.from_type(typing.Sequence[int])`
	`1162`	`+assert_no_examples(s,lambdax:isinstance(x,tuple))`
	`1163`	`+`
	`1164`	`+`
`1149`	`1165`	`deftest_custom_strategy_function_resolves_types_conditionally():`
`1150`	`1166`	`sentinel=object()`
`1151`	`1167`

Lines changed: 24 additions & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -125,3 +125,27 @@ def test_can_register_builtin_list():`
`125`	`125`	`st.from_type(list[int]),`
`126`	`126`	`lambdals:len(ls)<=2and {type(x)forxinls}.issubset({int}),`
`127`	`127`	`)`
	`128`	`+`
	`129`	`+`
	`130`	`+T=typing.TypeVar("T")`
	`131`	`+`
	`132`	`+`
	`133`	`+@typing.runtime_checkable`
	`134`	`+classFooable(typing.Protocol[T]):`
	`135`	`+deffoo(self):`
	`136`	`+ ...`
	`137`	`+`
	`138`	`+`
	`139`	`+classFooableConcrete(tuple):`
	`140`	`+deffoo(self):`
	`141`	`+pass`
	`142`	`+`
	`143`	`+`
	`144`	`+deftest_only_tuple_subclasses_in_typing_type():`
	`145`	`+# A generic typing type (such as Fooable) whose only concrete`
	`146`	`+# instantiations are tuples should still generate tuples. This is in`
	`147`	`+# contrast to test_tuple_subclasses_not_generic_sequences, which discards`
	`148`	`+# tuples if there are any alternatives.`
	`149`	`+withtemp_registered(FooableConcrete,st.builds(FooableConcrete)):`
	`150`	`+s=st.from_type(Fooable[int])`
	`151`	`+assert_all_examples(s,lambdax:type(x)isFooableConcrete)`

Comments

(0)