def test_typevar_dims(self): self.assertEqual(parse('M * bool', self.sym), ct.DataShape(ct.TypeVar('M'), ct.bool_)) self.assertEqual(parse('A * B * bool', self.sym), ct.DataShape(ct.TypeVar('A'), ct.TypeVar('B'), ct.bool_)) self.assertEqual(parse('A... * X * 3 * bool', self.sym), ct.DataShape(ct.Ellipsis(ct.TypeVar('A')), ct.TypeVar('X'), ct.Fixed(3), ct.bool_))
def test_ellipses(self): self.assertEqual(parse('... * bool', self.sym), ct.DataShape(ct.Ellipsis(), ct.bool_)) self.assertEqual(parse('M * ... * bool', self.sym), ct.DataShape(ct.TypeVar('M'), ct.Ellipsis(), ct.bool_)) self.assertEqual(parse('M * ... * 3 * bool', self.sym), ct.DataShape(ct.TypeVar('M'), ct.Ellipsis(), ct.Fixed(3), ct.bool_))
def resolver(tvar, tvdict): if tvar == T.Ellipsis(T.TypeVar('R')): a = tvdict[T.Ellipsis(T.TypeVar('A'))] b = tvdict[T.TypeVar('B')] result = [b] for x in a: result.extend([x, b]) return result elif tvar == T.TypeVar('T'): return T.int16
def test_binary_dtype_constr(self): # Create a symbol table with no types in it, so we can # make some isolated type constructors for testing sym = datashape.TypeSymbolTable(bare=True) # A limited set of dtypes for testing sym.dtype['int8'] = ct.int8 sym.dtype['uint16'] = ct.uint16 sym.dtype['float64'] = ct.float64 # TypeVar type constructor sym.dtype_constr['typevar'] = ct.TypeVar # Binary dtype constructor that asserts on the argument values expected_arg = [None, None] def _binary_type_constr(a, b): self.assertEqual(a, expected_arg[0]) self.assertEqual(b, expected_arg[1]) expected_arg[0] = None expected_arg[1] = None return ct.float32 sym.dtype_constr['binary'] = _binary_type_constr def assertExpectedParse(ds_str, expected_a, expected_b): # Set the expected value, and call the parser expected_arg[0] = expected_a expected_arg[1] = expected_b self.assertEqual(parse(ds_str, sym), ct.DataShape(ct.float32)) # Make sure the expected value was actually run by # check that it reset the expected value to None self.assertEqual(expected_arg, [None, None], 'The test binary type constructor did not run') # Positional args assertExpectedParse('binary[1, 0]', 1, 0) assertExpectedParse('binary[0, "test"]', 0, 'test') assertExpectedParse('binary[int8, "test"]', ct.DataShape(ct.int8), 'test') assertExpectedParse('binary[[1,3,5], "test"]', [1, 3, 5], 'test') # Positional and keyword args assertExpectedParse('binary[0, b=1]', 0, 1) assertExpectedParse('binary["test", b=A]', 'test', ct.DataShape(ct.TypeVar('A'))) assertExpectedParse('binary[[3, 6], b=int8]', [3, 6], ct.DataShape(ct.int8)) assertExpectedParse('binary[Arg, b=["x", "test"]]', ct.DataShape(ct.TypeVar('Arg')), ['x', 'test']) # Keyword args assertExpectedParse('binary[a=1, b=0]', 1, 0) assertExpectedParse('binary[a=[int8, A, uint16], b="x"]', [ ct.DataShape(ct.int8), ct.DataShape(ct.TypeVar('A')), ct.DataShape(ct.uint16) ], 'x')
def test_var_dims(self): self.assertEqual(parse('var * bool', self.sym), ct.DataShape(ct.Var(), ct.bool_)) self.assertEqual(parse('var * var * bool', self.sym), ct.DataShape(ct.Var(), ct.Var(), ct.bool_)) self.assertEqual(parse('M * 5 * var * bool', self.sym), ct.DataShape(ct.TypeVar('M'), ct.Fixed(5), ct.Var(), ct.bool_))
def test_match_equation_dtype(self): # A simple coercion eqns = _match_equation(dshape('int32'), dshape('int64')) self.assertEqual(eqns, [(T.int32, T.int64)]) # Matching a data type variable eqns = _match_equation(dshape('int32'), dshape('D')) self.assertEqual(eqns, [(T.int32, T.TypeVar('D'))])
def test_match_equation_dim(self): # Broadcasting a single dimension eqns = _match_equation(dshape('1 * int32'), dshape('10 * int32')) self.assertEqual(eqns, [(T.Fixed(1), T.Fixed(10)), (T.int32, T.int32)]) # Matching a dim type variable eqns = _match_equation(dshape('3 * int32'), dshape('M * int32')) self.assertEqual(eqns, [(T.Fixed(3), T.TypeVar('M')), (T.int32, T.int32)])
def test_unary_dtype_constr(self): # Create a symbol table with no types in it, so we can # make some isolated type constructors for testing sym = datashape.TypeSymbolTable(bare=True) # A limited set of dtypes for testing sym.dtype['int8'] = ct.int8 sym.dtype['uint16'] = ct.uint16 sym.dtype['float64'] = ct.float64 # TypeVar type constructor sym.dtype_constr['typevar'] = ct.TypeVar # Unary dtype constructor that asserts on the argument value expected_blah = [None] def _unary_type_constr(blah): self.assertEqual(blah, expected_blah[0]) expected_blah[0] = None return ct.float32 sym.dtype_constr['unary'] = _unary_type_constr def assertExpectedParse(ds_str, expected): # Set the expected value, and call the parser expected_blah[0] = expected self.assertEqual(parse(ds_str, sym), ct.DataShape(ct.float32)) # Make sure the expected value was actually run by # check that it reset the expected value to None self.assertEqual(expected_blah[0], None, 'The test unary type constructor did not run') # Integer parameter (positional) assertExpectedParse('unary[0]', 0) assertExpectedParse('unary[100000]', 100000) # String parameter (positional) assertExpectedParse('unary["test"]', 'test') assertExpectedParse("unary['test']", 'test') assertExpectedParse('unary["\\uc548\\ub155"]', u'\uc548\ub155') assertExpectedParse(u'unary["\uc548\ub155"]', u'\uc548\ub155') # DataShape parameter (positional) assertExpectedParse('unary[int8]', ct.DataShape(ct.int8)) assertExpectedParse('unary[X]', ct.DataShape(ct.TypeVar('X'))) # Empty list parameter (positional) assertExpectedParse('unary[[]]', []) # List of integers parameter (positional) assertExpectedParse('unary[[0, 3, 12]]', [0, 3, 12]) # List of strings parameter (positional) assertExpectedParse('unary[["test", "one", "two"]]', ["test", "one", "two"]) # List of datashapes parameter (positional) assertExpectedParse('unary[[float64, int8, uint16]]', [ ct.DataShape(ct.float64), ct.DataShape(ct.int8), ct.DataShape(ct.uint16) ]) # Integer parameter (keyword) assertExpectedParse('unary[blah=0]', 0) assertExpectedParse('unary[blah=100000]', 100000) # String parameter (keyword) assertExpectedParse('unary[blah="test"]', 'test') assertExpectedParse("unary[blah='test']", 'test') assertExpectedParse('unary[blah="\\uc548\\ub155"]', u'\uc548\ub155') assertExpectedParse(u'unary[blah="\uc548\ub155"]', u'\uc548\ub155') # DataShape parameter (keyword) assertExpectedParse('unary[blah=int8]', ct.DataShape(ct.int8)) assertExpectedParse('unary[blah=X]', ct.DataShape(ct.TypeVar('X'))) # Empty list parameter (keyword) assertExpectedParse('unary[blah=[]]', []) # List of integers parameter (keyword) assertExpectedParse('unary[blah=[0, 3, 12]]', [0, 3, 12]) # List of strings parameter (keyword) assertExpectedParse('unary[blah=["test", "one", "two"]]', ["test", "one", "two"]) # List of datashapes parameter (keyword) assertExpectedParse('unary[blah=[float64, int8, uint16]]', [ ct.DataShape(ct.float64), ct.DataShape(ct.int8), ct.DataShape(ct.uint16) ])
args += ((), ) # ------------------------------------------------- # keywords (**kwargs) if kwargs and not argspec.keywords: unreachable() elif kwargs: args += (kwargs, ) elif argspec.keywords: args += ({}, ) return ArgSpec(f, args) freshvar = lambda: T.TypeVar(gensym()) def dummy_signature(f): """Create a dummy signature for `f`""" argspec = inspect.getargspec(f) n = len(argspec.args) argtypes = [freshvar() for i in range(n)] restype = freshvar() if argspec.varargs: argtypes.append(freshvar()) if argspec.keywords: argtypes.append(freshvar())
def test_match_equation_ellipsis(self): # Matching an ellipsis eqns = _match_equation(dshape('int32'), dshape('... * int32')) self.assertEqual(eqns, [([], T.Ellipsis()), (T.int32, T.int32)]) eqns = _match_equation(dshape('3 * int32'), dshape('... * int32')) self.assertEqual(eqns, [([T.Fixed(3)], T.Ellipsis()), (T.int32, T.int32)]) eqns = _match_equation(dshape('3 * var * int32'), dshape('... * int32')) self.assertEqual(eqns, [([T.Fixed(3), T.Var()], T.Ellipsis()), (T.int32, T.int32)]) # Matching an ellipsis type variable eqns = _match_equation(dshape('int32'), dshape('A... * int32')) self.assertEqual(eqns, [([], T.Ellipsis(T.TypeVar('A'))), (T.int32, T.int32)]) eqns = _match_equation(dshape('3 * int32'), dshape('A... * int32')) self.assertEqual(eqns, [([T.Fixed(3)], T.Ellipsis(T.TypeVar('A'))), (T.int32, T.int32)]) eqns = _match_equation(dshape('3 * var * int32'), dshape('A... * int32')) self.assertEqual(eqns, [([T.Fixed(3), T.Var()], T.Ellipsis(T.TypeVar('A'))), (T.int32, T.int32)]) # Matching an ellipsis with a dim type variable on the left eqns = _match_equation(dshape('3 * var * int32'), dshape('A * B... * int32')) self.assertEqual(eqns, [(T.Fixed(3), T.TypeVar('A')), ([T.Var()], T.Ellipsis(T.TypeVar('B'))), (T.int32, T.int32)]) # Matching an ellipsis with a dim type variable on the right eqns = _match_equation(dshape('3 * var * int32'), dshape('A... * B * int32')) self.assertEqual(eqns, [([T.Fixed(3)], T.Ellipsis(T.TypeVar('A'))), (T.Var(), T.TypeVar('B')), (T.int32, T.int32)]) # Matching an ellipsis with a dim type variable on both sides eqns = _match_equation(dshape('3 * var * int32'), dshape('A * B... * C * int32')) self.assertEqual(eqns, [(T.Fixed(3), T.TypeVar('A')), ([], T.Ellipsis(T.TypeVar('B'))), (T.Var(), T.TypeVar('C')), (T.int32, T.int32)]) eqns = _match_equation(dshape('3 * var * 4 * M * int32'), dshape('A * B... * C * int32')) self.assertEqual(eqns, [(T.Fixed(3), T.TypeVar('A')), ([T.Var(), T.Fixed(4)], T.Ellipsis(T.TypeVar('B'))), (T.TypeVar('M'), T.TypeVar('C')), (T.int32, T.int32)])