test_buffer.py revision 0c51595a784787d8e198af910cb6d79172ee52bb
19a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 29a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The ndarray object from _testbuffer.c is a complete implementation of 39a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# a PEP-3118 buffer provider. It is independent from NumPy's ndarray 49a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# and the tests don't require NumPy. 59a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 69a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# If NumPy is present, some tests check both ndarray implementations 79a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# against each other. 89a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 99a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Most ndarray tests also check that memoryview(ndarray) behaves in 109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# the same way as the original. Thus, a substantial part of the 119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memoryview tests is now in this module. 129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1431084ba52856329b972b84299b438bf5b73be292Antoine Pitrouimport contextlib 159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport unittest 169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom test import support 179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom itertools import permutations, product 189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom random import randrange, sample, choice 199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom sysconfig import get_config_var 209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport warnings 219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport sys, array, io 229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom decimal import Decimal 239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom fractions import Fraction 249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah from _testbuffer import * 279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndarray = None 299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah import struct 329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct = None 349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 3606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan import ctypes 3706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlanexcept ImportError: 3806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ctypes = None 3906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 4006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlantry: 419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with warnings.catch_warnings(): 429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah from numpy import ndarray as numpy_array 439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_array = None 459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 479a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahSHORT_TEST = True 489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Random lists by format specifier 529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Native format chars and their ranges. 559a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahNATIVE = { 569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '?':0, 'c':0, 'b':0, 'B':0, 579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'h':0, 'H':0, 'i':0, 'I':0, 589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'l':0, 'L':0, 'n':0, 'N':0, 599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f':0, 'd':0, 'P':0 609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah# NumPy does not have 'n' or 'N': 637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krahif numpy_array: 647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah del NATIVE['n'] 657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah del NATIVE['N'] 667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif struct: 689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Add "qQ" if present in native mode. 709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack('Q', 2**64-1) 719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah NATIVE['q'] = 0 729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah NATIVE['Q'] = 0 739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Standard format chars and their ranges. 779a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahSTANDARD = { 789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '?':(0, 2), 'c':(0, 1<<8), 799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'b':(-(1<<7), 1<<7), 'B':(0, 1<<8), 809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'h':(-(1<<15), 1<<15), 'H':(0, 1<<16), 819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'i':(-(1<<31), 1<<31), 'I':(0, 1<<32), 829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'l':(-(1<<31), 1<<31), 'L':(0, 1<<32), 839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'q':(-(1<<63), 1<<63), 'Q':(0, 1<<64), 849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f':(-(1<<63), 1<<63), 'd':(-(1<<1023), 1<<1023) 859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef native_type_range(fmt): 889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return range of a native type.""" 899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c': 909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (0, 256) 919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == '?': 929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (0, 2) 939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == 'f': 949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<63), 1<<63) 959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == 'd': 969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<1023), 1<<1023) 979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for exp in (128, 127, 64, 63, 32, 31, 16, 15, 8, 7): 999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 1009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack(fmt, (1<<exp)-1) 1019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 1029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 1039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 1049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<exp), 1<<exp) if exp & 1 else (0, 1<<exp) 1059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lh 1069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict = { 1089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '':NATIVE, 1099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '@':NATIVE, 1109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '<':STANDARD, 1119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '>':STANDARD, 1129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '=':STANDARD, 1139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '!':STANDARD 1149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 1159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif struct: 1179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 1189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmtdict['@'][fmt] = native_type_range(fmt) 1199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1209a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMEMORYVIEW = NATIVE.copy() 1219a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahARRAY = NATIVE.copy() 1229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfor k in NATIVE: 1239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not k in "bBhHiIlLfd": 1249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del ARRAY[k] 1259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1269a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahBYTEFMT = NATIVE.copy() 1279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfor k in NATIVE: 1289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not k in "Bbc": 1299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del BYTEFMT[k] 1309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['m'] = MEMORYVIEW 1329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['@m'] = MEMORYVIEW 1339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['a'] = ARRAY 1349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['b'] = BYTEFMT 1359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['@b'] = BYTEFMT 1369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Capabilities of the test objects: 1389a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMODE = 0 1399a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMULT = 1 1409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahcap = { # format chars # multiplier 1419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'ndarray': (['', '@', '<', '>', '=', '!'], ['', '1', '2', '3']), 1429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'array': (['a'], ['']), 1439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'numpy': ([''], ['']), 1449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'memoryview': (['@m', 'm'], ['']), 1459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'bytefmt': (['@b', 'b'], ['']), 1469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 1479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randrange_fmt(mode, char, obj): 1499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random item for a type specified by a mode and a single 1509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format character.""" 1519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = randrange(*fmtdict[mode][char]) 1529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == 'c': 15374a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka x = bytes([x]) 15474a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka if obj == 'numpy' and x == b'\x00': 15574a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka # http://projects.scipy.org/numpy/ticket/1925 15674a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka x = b'\x01' 1579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == '?': 1589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bool(x) 1599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == 'f' or char == 'd': 1609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(char, x) 1619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.unpack(char, x)[0] 1629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x 1639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gen_item(fmt, obj): 1659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return single random item.""" 1669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode, chars = fmt.split('#') 1679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = [] 1689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for c in chars: 1699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x.append(randrange_fmt(mode, c, obj)) 1709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x[0] if len(x) == 1 else tuple(x) 1719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gen_items(n, fmt, obj): 1739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return a list of random items (or a scalar).""" 1749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n == 0: 1759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return gen_item(fmt, obj) 1769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * n 1779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(n): 1789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = gen_item(fmt, obj) 1799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 1809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef struct_items(n, obj): 1829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode = choice(cap[obj][MODE]) 1839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xfmt = mode + '#' 1849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode.strip('amb') 1859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nmemb = randrange(2, 10) # number of struct members 1869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(nmemb): 1879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char = choice(tuple(fmtdict[mode])) 1889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multiplier = choice(cap[obj][MULT]) 1899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xfmt += (char * int(multiplier if multiplier else 1)) 1909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt += (multiplier + char) 1919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = gen_items(n, xfmt, obj) 1929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = gen_item(xfmt, obj) 1939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return fmt, items, item 1949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randitems(n, obj='ndarray', mode=None, char=None): 1969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random format, items, item.""" 1979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if mode is None: 1989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode = choice(cap[obj][MODE]) 1999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char is None: 2009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char = choice(tuple(fmtdict[mode])) 2019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multiplier = choice(cap[obj][MULT]) 2029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode + '#' + char * int(multiplier if multiplier else 1) 2039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = gen_items(n, fmt, obj) 2049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = gen_item(fmt, obj) 2059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode.strip('amb') + multiplier + char 2069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return fmt, items, item 2079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef iter_mode(n, obj='ndarray'): 2099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Iterate through supported mode/char combinations.""" 2109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for mode in cap[obj][MODE]: 2119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict[mode]: 2129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield randitems(n, obj, mode, char) 2139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef iter_format(nitems, testobj='ndarray'): 2159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Yield (format, items, item) for all possible modes and format 2169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah characters plus one random compound format string.""" 2179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for t in iter_mode(nitems, testobj): 2189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield t 2199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if testobj != 'ndarray': 220bb6c0aaebfbeb9ab13886e261df904c9c12853b9Raymond Hettinger return 2219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield struct_items(nitems, testobj) 2229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_byte_format(fmt): 2259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 'c' in fmt or 'b' in fmt or 'B' in fmt 2269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_memoryview_format(fmt): 2289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """format suitable for memoryview""" 2299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = len(fmt) 2309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ((x == 1 or (x == 2 and fmt[0] == '@')) and 2319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt[x-1] in MEMORYVIEW) 2329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2339a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahNON_BYTE_FORMAT = [c for c in fmtdict['@'] if not is_byte_format(c)] 2349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 2379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Multi-dimensional tolist(), slicing and slice assignments 2389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 2399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef atomp(lst): 2419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Tuple items (representing structs) are regarded as atoms.""" 2429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return not isinstance(lst, list) 2439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef listp(lst): 2459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return isinstance(lst, list) 2469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef prod(lst): 2489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Product of list elements.""" 2499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(lst) == 0: 2509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 2519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = lst[0] 2529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in lst[1:]: 2539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x *= v 2549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x 2559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef strides_from_shape(ndim, shape, itemsize, layout): 2579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Calculate strides of a contiguous array. Layout is 'C' or 2589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'F' (Fortran).""" 2599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim == 0: 2609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return () 2619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if layout == 'C': 2629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = list(shape[1:]) + [itemsize] 2639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim-2, -1, -1): 2649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] *= strides[i+1] 2659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 2669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [itemsize] + list(shape[:-1]) 2679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(1, ndim): 2689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] *= strides[i-1] 2699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return strides 2709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _ca(items, s): 2729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert flat item list to the nested list representation of a 2739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multidimensional C array with shape 's'.""" 2749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(items): 2759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items 2769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(s) == 0: 2779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items[0] 2789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * s[0] 2799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride = len(items) // s[0] if s[0] else 0 2809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(s[0]): 2819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = i*stride 2829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = _ca(items[start:start+stride], s[1:]) 2839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 2849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _fa(items, s): 2869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert flat item list to the nested list representation of a 2879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multidimensional Fortran array with shape 's'.""" 2889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(items): 2899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items 2909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(s) == 0: 2919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items[0] 2929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * s[0] 2939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride = s[0] 2949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(s[0]): 2959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = _fa(items[i::stride], s[1:]) 2969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 2979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef carray(items, shape): 2999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if listp(items) and not 0 in shape and prod(shape) != len(items): 3009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("prod(shape) != len(items)") 3019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _ca(items, shape) 3029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef farray(items, shape): 3049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if listp(items) and not 0 in shape and prod(shape) != len(items): 3059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("prod(shape) != len(items)") 3069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _fa(items, shape) 3079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef indices(shape): 3099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible tuples of indices.""" 3109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iterables = [range(v) for v in shape] 3119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(*iterables) 3129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef getindex(ndim, ind, strides): 3149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert multi-dimensional index to the position in the flat list.""" 3159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ret = 0 3169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 3179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ret += strides[i] * ind[i] 3189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ret 3199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef transpose(src, shape): 3219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Transpose flat item list that is regarded as a multi-dimensional 3229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah matrix defined by shape: dest...[k][j][i] = src[i][j][k]... """ 3239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape: 3249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return src 3259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 3269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sstrides = strides_from_shape(ndim, shape, 1, 'C') 3279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dstrides = strides_from_shape(ndim, shape[::-1], 1, 'C') 3289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dest = [0] * len(src) 3299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 3309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fr = getindex(ndim, ind, sstrides) 3319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah to = getindex(ndim, ind[::-1], dstrides) 3329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dest[to] = src[fr] 3339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return dest 3349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _flatten(lst): 3369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """flatten list""" 3379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lst == []: 3389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [lst] 3419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _flatten(lst[0]) + _flatten(lst[1:]) 3429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef flatten(lst): 3449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """flatten list or return scalar""" 3459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): # scalar 3469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _flatten(lst) 3489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef slice_shape(lst, slices): 3509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Get the shape of lst after slicing: slices is a list of slice 3519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah objects.""" 3529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [] 3549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [len(lst[slices[0]])] + slice_shape(lst[0], slices[1:]) 3559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef multislice(lst, slices): 3579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Multi-dimensional slicing: slices is a list of slice objects.""" 3589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [multislice(sublst, slices[1:]) for sublst in lst[slices[0]]] 3619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef m_assign(llst, rlst, lslices, rslices): 3639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Multi-dimensional slice assignment: llst and rlst are the operands, 3649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices and rslices are lists of slice objects. llst and rlst must 3659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have the same structure. 3669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah For a two-dimensional example, this is not implemented in Python: 3689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah llst[0:3:2, 0:3:2] = rlst[1:3:1, 1:3:1] 3709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah Instead we write: 3729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [slice(0,3,2), slice(0,3,2)] 3749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices = [slice(1,3,1), slice(1,3,1)] 3759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multislice_assign(llst, rlst, lslices, rslices) 3769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 3779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(rlst): 3789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return rlst 3799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rlst = [m_assign(l, r, lslices[1:], rslices[1:]) 3809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for l, r in zip(llst[lslices[0]], rlst[rslices[0]])] 3819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah llst[lslices[0]] = rlst 3829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return llst 3839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef cmp_structure(llst, rlst, lslices, rslices): 3859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Compare the structure of llst[lslices] and rlst[rslices].""" 3869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape = slice_shape(llst, lslices) 3879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape = slice_shape(rlst, rslices) 3889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (len(lshape) != len(rshape)): 3899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return -1 3909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(len(lshape)): 3919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lshape[i] != rshape[i]: 3929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return -1 3939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lshape[i] == 0: 3949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 3959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 3969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef multislice_assign(llst, rlst, lslices, rslices): 3989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return llst after assigning: llst[lslices] = rlst[rslices]""" 3999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if cmp_structure(llst, rlst, lslices, rslices) < 0: 4009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("lvalue and rvalue have different structures") 4019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return m_assign(llst, rlst, lslices, rslices) 4029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 4059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Random structures 4069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 4079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# PEP-3118 is very permissive with respect to the contents of a 4109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Py_buffer. In particular: 4119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - shape can be zero 4139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - strides can be any integer, including zero 4149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - offset can point to any location in the underlying 4159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memory block, provided that it is a multiple of 4169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# itemsize. 4179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The functions in this section test and verify random structures 4199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# in full generality. A structure is valid iff it fits in the 4209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# underlying memory block. 4219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The structure 't' (short for 'tuple') is fully defined by: 4239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# t = (memlen, itemsize, ndim, shape, strides, offset) 4259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef verify_structure(memlen, itemsize, ndim, shape, strides, offset): 4289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Verify that the parameters represent a valid array within 4299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah the bounds of the allocated memory: 4309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char *mem: start of the physical memory block 4319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen: length of the physical memory block 4329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset: (char *)buf - mem 4339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 4349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if offset % itemsize: 4359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if offset < 0 or offset+itemsize > memlen: 4379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if any(v % itemsize for v in strides): 4399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim <= 0: 4429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ndim == 0 and not shape and not strides 4439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in shape: 4449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return True 4459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = sum(strides[j]*(shape[j]-1) for j in range(ndim) 4479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] <= 0) 4489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imax = sum(strides[j]*(shape[j]-1) for j in range(ndim) 4499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] > 0) 4509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 <= offset+imin and offset+imax+itemsize <= memlen 4529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef get_item(lst, indices): 4549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in indices: 4559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = lst[i] 4569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 4579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef memory_index(indices, t): 4599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Location of an item in the underlying memory.""" 4609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 4619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah p = offset 4629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 4639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah p += strides[i]*indices[i] 4649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return p 4659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_overlapping(t): 4679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """The structure 't' is overlapping if at least one memory location 4689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is visited twice while iterating through all possible tuples of 4699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah indices.""" 4709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 4719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah visited = 1<<memlen 4729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 4739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah i = memory_index(ind, t) 4749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bit = 1<<i 4759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if visited & bit: 4769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return True 4779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah visited |= bit 4789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rand_structure(itemsize, valid, maxdim=5, maxshape=16, shape=()): 4819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random structure: 4829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (memlen, itemsize, ndim, shape, strides, offset) 4839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If 'valid' is true, the returned structure is valid, otherwise invalid. 4849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If 'shape' is given, use that instead of creating a random shape. 4859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 4869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape: 4879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(maxdim+1) 4889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (ndim == 0): 4899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if valid: 4909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return itemsize, itemsize, ndim, (), (), 0 4919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 4929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 16+1) 4939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = nitems * itemsize 4949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -itemsize if randrange(2) == 0 else memlen 4959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return memlen, itemsize, ndim, (), (), offset 4969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 2 4989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 4999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n >= 95 and valid: 5009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 0 5019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif n >= 90: 5029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 5039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [0] * ndim 5049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 5069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape[i] = randrange(minshape, maxshape+1) 5079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 5099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstride = 5 5119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 5129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zero_stride = True if n >= 95 and n & 1 else False 5139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [0] * ndim 5159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[ndim-1] = itemsize * randrange(-maxstride, maxstride+1) 5169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not zero_stride and strides[ndim-1] == 0: 5179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[ndim-1] = itemsize 5189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim-2, -1, -1): 5209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstride *= shape[i+1] if shape[i+1] else 1 5219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if zero_stride: 5229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] = itemsize * randrange(-maxstride, maxstride+1) 5239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] = ((1,-1)[randrange(2)] * 5259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize * randrange(1, maxstride+1)) 5269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = imax = 0 5289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not 0 in shape: 5299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = sum(strides[j]*(shape[j]-1) for j in range(ndim) 5309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] <= 0) 5319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imax = sum(strides[j]*(shape[j]-1) for j in range(ndim) 5329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] > 0) 5339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = imax - imin 5359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if valid: 5369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -imin * itemsize 5379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = offset + (imax+1) * itemsize 5389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = (-imin + imax) * itemsize 5409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -imin-itemsize if randrange(2) == 0 else memlen 5419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return memlen, itemsize, ndim, shape, strides, offset 5429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randslice_from_slicelen(slicelen, listlen): 5449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create a random slice of len slicelen that fits into listlen.""" 5459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstart = listlen - slicelen 5469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = randrange(maxstart+1) 5479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstep = (listlen - start) // slicelen if slicelen else 1 5489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah step = randrange(1, maxstep+1) 5499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stop = start + slicelen * step 5509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s = slice(start, stop, step) 5519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _, _, _, control = slice_indices(s, listlen) 5529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if control != slicelen: 5539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise RuntimeError 5549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return s 5559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randslice_from_shape(ndim, shape): 5579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create two sets of slices for an array x with shape 'shape' 5589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah such that shapeof(x[lslices]) == shapeof(x[rslices]).""" 5599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [0] * ndim 5609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices = [0] * ndim 5619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(ndim): 5629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah l = shape[n] 5639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(1, l+1) if l > 0 else 0 5649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices[n] = randslice_from_slicelen(slicelen, l) 5659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n] = randslice_from_slicelen(slicelen, l) 5669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return tuple(lslices), tuple(rslices) 5679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rand_aligned_slices(maxdim=5, maxshape=16): 5699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create (lshape, rshape, tuple(lslices), tuple(rslices)) such that 5709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shapeof(x[lslices]) == shapeof(y[rslices]), where x is an array 5719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with shape 'lshape' and y is an array with shape 'rshape'.""" 5729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(1, maxdim+1) 5739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 2 5749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 5759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n >= 95: 5769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 0 5779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif n >= 90: 5789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 5799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah all_random = True if randrange(100) >= 80 else False 5809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape = [0]*ndim; rshape = [0]*ndim 5819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [0]*ndim; rslices = [0]*ndim 5829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(ndim): 5849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah small = randrange(minshape, maxshape+1) 5859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah big = randrange(minshape, maxshape+1) 5869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if big < small: 5879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah big, small = small, big 5889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create a slice that fits the smaller value. 5909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if all_random: 5919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = randrange(-small, small+1) 5929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stop = randrange(-small, small+1) 5939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah step = (1,-1)[randrange(2)] * randrange(1, small+2) 5949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_small = slice(start, stop, step) 5959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _, _, _, slicelen = slice_indices(s_small, small) 5969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(1, small+1) if small > 0 else 0 5989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_small = randslice_from_slicelen(slicelen, small) 5999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create a slice of the same length for the bigger value. 6019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_big = randslice_from_slicelen(slicelen, big) 6029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if randrange(2) == 0: 6039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape[n], lshape[n] = big, small 6049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n], lslices[n] = s_big, s_small 6059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 6069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape[n], lshape[n] = small, big 6079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n], lslices[n] = s_small, s_big 6089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lshape, rshape, tuple(lslices), tuple(rslices) 6109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randitems_from_structure(fmt, t): 6129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return a list of random items for structure 't' with format 6139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'fmtchar'.""" 6149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, _, _, _, _ = t 6159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return gen_items(memlen//itemsize, '#'+fmt, 'numpy') 6169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef ndarray_from_structure(items, fmt, t, flags=0): 6189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return ndarray from the tuple returned by rand_structure()""" 6199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 6209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ndarray(items, shape=shape, strides=strides, format=fmt, 6219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset=offset, flags=ND_WRITABLE|flags) 6229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef numpy_array_from_structure(items, fmt, t): 6249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return numpy_array from the tuple returned by rand_structure()""" 6259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 6269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = bytearray(memlen) 6279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j, v in enumerate(items): 6289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, buf, j*itemsize, v) 6299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return numpy_array(buffer=buf, shape=shape, strides=strides, 6309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dtype=fmt, offset=offset) 6319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memoryview casts 6359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef cast_items(exporter, fmt, itemsize, shape=None): 6389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Interpret the raw memory of 'exporter' as a list of items with 6399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size 'itemsize'. If shape=None, the new structure is assumed to 6409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah be 1-D with n * itemsize = bytelen. If shape is given, the usual 6419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah constraint for contiguous arrays prod(shape) * itemsize = bytelen 6429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah applies. On success, return (items, shape). If the constraints 6439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cannot be met, return (None, None). If a chunk of bytes is interpreted 6449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah as NaN as a result of float conversion, return ('nan', None).""" 6459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytelen = exporter.nbytes 6469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape: 6479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if prod(shape) * itemsize != bytelen: 6489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif shape == []: 6509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if exporter.ndim == 0 or itemsize != bytelen: 6519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 6539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n, r = divmod(bytelen, itemsize) 6549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [n] 6559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if r != 0: 6569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mem = exporter.tobytes() 6599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah byteitems = [mem[i:i+itemsize] for i in range(0, len(mem), itemsize)] 6609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [] 6629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in byteitems: 6639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = struct.unpack(fmt, v)[0] 6649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if item != item: 6659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 'nan', shape 6669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items.append(item) 6679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return (items, shape) if shape != [] else (items[0], shape) 6699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gencastshapes(): 6719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate shapes to test casting.""" 6729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(32): 6739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [n] 6749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(4, 6) 6759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 if randrange(100) > 80 else 2 6769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [randrange(minshape, 5) for _ in range(ndim)] 6779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(2, 4) 6789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 if randrange(100) > 80 else 2 6799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [randrange(minshape, 5) for _ in range(ndim)] 6809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Actual tests 6849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef genslices(n): 6879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible slices for a single dimension.""" 6889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(range(-n, n+1), range(-n, n+1), range(-n, n+1)) 6899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef genslices_ndim(ndim, shape): 6919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible slice tuples for 'shape'.""" 6929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iterables = [genslices(shape[n]) for n in range(ndim)] 6939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(*iterables) 6949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslice(n, allow_empty=False): 6969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slice for a single dimension of length n. 6979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If zero=True, the slices may be empty, otherwise they will 6989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah be non-empty.""" 6999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minlen = 0 if allow_empty or n == 0 else 1 7009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(minlen, n+1) 7019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return randslice_from_slicelen(slicelen, n) 7029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslices(n, allow_empty=False): 7049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slices for a single dimension.""" 7059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(5): 7069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield rslice(n, allow_empty) 7079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslices_ndim(ndim, shape, iterations=5): 7099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slice tuples for 'shape'.""" 7109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-empty slices 7119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(iterations): 7129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(rslice(shape[n]) for n in range(ndim)) 7139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # possibly empty slices 7149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(iterations): 7159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(rslice(shape[n], allow_empty=True) for n in range(ndim)) 7169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slices 7179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(slice(0,1,0) for _ in range(ndim)) 7189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rpermutation(iterable, r=None): 7209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pool = tuple(iterable) 7219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = len(pool) if r is None else r 7229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(sample(pool, r)) 7239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef ndarray_print(nd): 7259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Print ndarray for debugging.""" 7269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 7279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd.tolist() 7289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except (TypeError, NotImplementedError): 7299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd.tobytes() 7309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(nd, ndarray): 7319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = nd.offset 7329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags = nd.flags 7339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 7349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = 'unknown' 7359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags = 'unknown' 7369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah print("ndarray(%s, shape=%s, strides=%s, suboffsets=%s, offset=%s, " 7379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah "format='%s', itemsize=%s, flags=%s)" % 7389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (x, nd.shape, nd.strides, nd.suboffsets, offset, 7399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.format, nd.itemsize, flags)) 7409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sys.stdout.flush() 7419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7439a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahITERATIONS = 100 7449a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMAXDIM = 5 7459a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMAXSHAPE = 10 7469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif SHORT_TEST: 7489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ITERATIONS = 10 7499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah MAXDIM = 3 7509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah MAXSHAPE = 4 7519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah genslices = rslices 7529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah genslices_ndim = rslices_ndim 7539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah permutations = rpermutation 7549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah@unittest.skipUnless(struct, 'struct module required for this test.') 7579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah@unittest.skipUnless(ndarray, 'ndarray object required for this test') 7589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahclass TestBufferProtocol(unittest.TestCase): 7599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def setUp(self): 7615d953184a6fae25bf27e769c90b419d9b2aa1af9Stefan Krah # The suboffsets tests need sizeof(void *). 7625d953184a6fae25bf27e769c90b419d9b2aa1af9Stefan Krah self.sizeof_void_p = get_sizeof_void_p() 7639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def verify(self, result, obj=-1, 7659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize={1}, fmt=-1, readonly={1}, 7669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim={1}, shape=-1, strides=-1, 7679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=-1, sliced=False, cast=False): 7689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Verify buffer contents against expected values. Default values 7699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # are deliberately initialized to invalid types. 7709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape: 7719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = prod(shape)*itemsize 7729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 7739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not fmt: # array has been implicitly cast to unsigned bytes 7749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = len(lst) 7759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: # ndim = 0 7769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = itemsize 7779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Reconstruct suboffsets from strides. Support for slicing 7799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # could be added, but is currently only needed for test_getbuf(). 7809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffsets = () 7819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if result.suboffsets: 7829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertGreater(ndim, 0) 7839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffset0 = 0 7859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(1, ndim): 7869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape[n] == 0: 7879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 7889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[n] <= 0: 7899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffset0 += -strides[n] * (shape[n]-1) 7909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffsets = [suboffset0] + [-1 for v in range(ndim-1)] 7929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not correct if slicing has occurred in the first dimension. 7949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride0 = self.sizeof_void_p 7959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[0] < 0: 7969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride0 = -stride0 7979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [stride0] + list(strides[1:]) 7989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(result.obj, obj) 8009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.nbytes, expected_len) 8019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.itemsize, itemsize) 8029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.format, fmt) 8039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.readonly, readonly) 8049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.ndim, ndim) 8059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.shape, tuple(shape)) 8069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not (sliced and suboffsets): 8079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.strides, tuple(strides)) 8089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.suboffsets, tuple(suboffsets)) 8099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(result, ndarray) or is_memoryview_format(fmt): 8119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rep = result.tolist() if fmt else result.tobytes() 8129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(rep, lst) 8139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not fmt: # array has been cast to unsigned bytes, 8159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return # the remaining tests won't work. 8169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBuffer_GetPointer() is the definition how to access an item. 8189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # If PyBuffer_GetPointer(indices) is correct for all possible 8199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # combinations of indices, the buffer is correct. 8209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # 8219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Also test tobytes() against the flattened 'lst', with all items 8229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # packed to bytes. 8239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not cast: # casts chop up 'lst' in different ways 8249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray() 8259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf_err = None 8269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 8279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 8289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item1 = get_pointer(result, ind) 8299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item2 = get_item(lst, ind) 8309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(item2, tuple): 8319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(fmt, *item2) 8329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 8339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(fmt, item2) 8349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b.extend(x) 8359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except BufferError: 8369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf_err = True # re-exporter does not provide full buffer 8379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 8389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(item1, item2) 8399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not buf_err: 8419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # test tobytes() 8429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.tobytes(), b) 8439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # lst := expected multi-dimensional logical representation 8459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flatten(lst) := elements in C-order 8469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ff = fmt if fmt else 'B' 8479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flattened = flatten(lst) 8489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Rules for 'A': if the array is already contiguous, return 8509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # the array unaltered. Otherwise, return a contiguous 'C' 8519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # representation. 8529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 8539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = result 8549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if order == 'F': 8559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'C'): 8579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # For constructing the ndarray, convert the 8589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flattened logical representation to Fortran order. 8599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah trans = transpose(flattened, shape) 8609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(trans, shape=shape, format=ff, 8619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 8629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: # 'C', 'A' 8639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'F') and order == 'C': 8659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The flattened list is already in C-order. 8669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(flattened, shape=shape, format=ff) 8677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah contig = get_contiguous(result, PyBUF_READ, order) 8699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(contig.tobytes(), b) 8709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(contig, expected)) 8719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if ndim == 0: 8737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 8747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nmemb = len(flattened) 8767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ro = 0 if readonly else ND_WRITABLE 8777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### See comment in test_py_buffer_to_contiguous for an 8797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### explanation why these tests are valid. 8807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'C' 8827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'C', PyBUF_FULL_RO) 8837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 88406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 8857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 88606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 88706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 8887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro, format=fmt) 8907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 8917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'F' 8937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'F', PyBUF_FULL_RO) 8947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 89506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 8967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 89706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 89806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 8997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro|ND_FORTRAN, 9017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah format=fmt) 9027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'A' 9057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'A', PyBUF_FULL_RO) 9067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 90706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 9087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 90906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 91006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 9117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah f = ND_FORTRAN if is_contiguous(result, 'F') else 0 9137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=f|ro, format=fmt) 9147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 9179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 9189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(result) 9199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except BufferError: # re-exporter does not provide full information 9209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = result.obj if isinstance(result, memoryview) else result 9229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m.obj, ex) 9239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.nbytes, expected_len) 9249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.itemsize, itemsize) 9259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.format, fmt) 9269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.readonly, readonly) 9279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.ndim, ndim) 9289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.shape, tuple(shape)) 9299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not (sliced and suboffsets): 9309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.strides, tuple(strides)) 9319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.suboffsets, tuple(suboffsets)) 9329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 1 if ndim == 0 else len(lst) 9349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), n) 9359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rep = result.tolist() if fmt else result.tobytes() 9379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(rep, lst) 9389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, result) 9399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def verify_getbuf(self, orig_ex, ex, req, sliced=False): 9419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def simple_fmt(ex): 9429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ex.format == '' or ex.format == 'B' 9439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def match(req, flag): 9449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ((req&flag) == flag) 9459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (# writable request to read-only exporter 9479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (ex.readonly and match(req, PyBUF_WRITABLE)) or 9489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot match explicit contiguity request 9499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_C_CONTIGUOUS) and not ex.c_contiguous) or 9509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_F_CONTIGUOUS) and not ex.f_contiguous) or 9519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_ANY_CONTIGUOUS) and not ex.contiguous) or 9529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer needs suboffsets 9539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_INDIRECT) and ex.suboffsets) or 9549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer without strides must be C-contiguous 9559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_STRIDES) and not ex.c_contiguous) or 9569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_SIMPLE|PyBUF_FORMAT and PyBUF_WRITABLE|PyBUF_FORMAT 9579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_ND) and match(req, PyBUF_FORMAT))): 9589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=req) 9609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(ex, ndarray) or is_memoryview_format(ex.format): 9639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 9649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 9659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_FULL_RO) 9669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 9679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The consumer may have requested default values or a NULL format. 9699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ro = 0 if match(req, PyBUF_WRITABLE) else ex.readonly 9709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = ex.format 9719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = ex.itemsize 9729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = ex.ndim 9739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_FORMAT): 9749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # itemsize refers to the original itemsize before the cast. 9759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality product(shape) * itemsize = len still holds. 9769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality calcsize(format) = itemsize does _not_ hold. 9779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = '' 9789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = orig_ex.tobytes() # Issue 12834 9799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_ND): 9809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = 1 9819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = orig_ex.shape if match(req, PyBUF_ND) else () 9829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = orig_ex.strides if match(req, PyBUF_STRIDES) else () 9839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=req) 9859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=ex, 9869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=ro, 9879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 9889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, sliced=sliced) 9899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_getbuf(self): 9919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah requests = ( 9929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # distinct flags 9939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 9949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_C_CONTIGUOUS, PyBUF_F_CONTIGUOUS, PyBUF_ANY_CONTIGUOUS, 9959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # compound requests 9969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_FULL, PyBUF_FULL_RO, 9979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 9989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 9999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 10009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # items and format 10029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_fmt = ( 10039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([True if x % 2 else False for x in range(12)], '?'), 10049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'b'), 10059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'B'), 10069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([(2**31-x) if x % 2 else (-2**31+x) for x in range(12)], 'l') 10079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # shape, strides, offset 10099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah structure = ( 10109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([], [], 0), 1011363af44a4abff02ece61e456d55824f298448992Stefan Krah ([1,3,1], [], 0), 10129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [], 0), 10139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [-1], 11), 10149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [2], 0), 10159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [-2], 11), 10169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [], 0), 10179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [-4, -1], 11), 10189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [4, 1], 4), 10199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [-4, -1], 8) 10209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray creation flags 10229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndflags = ( 10239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 0, ND_WRITABLE, ND_FORTRAN, ND_FORTRAN|ND_WRITABLE, 10249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ND_PIL, ND_PIL|ND_WRITABLE 10259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags that can actually be used as flags 10279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah real_flags = (0, PyBUF_WRITABLE, PyBUF_FORMAT, 10289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_WRITABLE|PyBUF_FORMAT) 10299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, fmt in items_fmt: 10319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 10329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape, strides, offset in structure: 10339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [v * itemsize for v in strides] 10349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset *= itemsize 10359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in ndflags: 10369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides and (flags&ND_FORTRAN): 10389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape and (flags&ND_PIL): 10409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _items = items if shape else items[0] 10439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(_items, format=fmt, flags=flags, 10449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape=shape, strides=strides, offset=offset) 10459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ex1[::-2] if shape else None 10469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 10489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 10509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex1.ndim == 0 or (ex1.ndim == 1 and shape and strides): 10519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 10529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2 and ex2.ndim == 1 and shape and strides: 10539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 10549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for req in requests: 10569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bits in real_flags: 10579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, ex1, req|bits) 10589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, m1, req|bits) 10599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, ex2, req|bits, 10619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, m2, req|bits, 10639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 10669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_GETBUF_FAIL 10689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[12], flags=ND_GETBUF_FAIL) 10699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex) 10709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Request complex structure from a simple exporter. In this 10729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # particular case the test object is not PEP-3118 compliant. 10739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah base = ndarray([9], [1]) 10749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(base, getbuf=PyBUF_SIMPLE) 10759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_WRITABLE) 10769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ND) 10779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_STRIDES) 10789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_C_CONTIGUOUS) 10799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_F_CONTIGUOUS) 10809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ANY_CONTIGUOUS) 10819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 10829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1083363af44a4abff02ece61e456d55824f298448992Stefan Krah # Issue #22445: New precise contiguity definition. 1084363af44a4abff02ece61e456d55824f298448992Stefan Krah for shape in [1,12,1], [7,0,7]: 1085363af44a4abff02ece61e456d55824f298448992Stefan Krah for order in 0, ND_FORTRAN: 1086363af44a4abff02ece61e456d55824f298448992Stefan Krah ex = ndarray(items, shape=shape, flags=order|ND_WRITABLE) 1087363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(ex, 'F')) 1088363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(ex, 'C')) 1089363af44a4abff02ece61e456d55824f298448992Stefan Krah 1090363af44a4abff02ece61e456d55824f298448992Stefan Krah for flags in requests: 1091363af44a4abff02ece61e456d55824f298448992Stefan Krah nd = ndarray(ex, getbuf=flags) 1092363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(nd, 'F')) 1093363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(nd, 'C')) 1094363af44a4abff02ece61e456d55824f298448992Stefan Krah 10959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_exceptions(self): 10969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 10979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndm = ndarray([9], [1], flags=ND_VAREXPORT) 10989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Initialization of a new ndarray or mutation of an existing array. 11009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for c in (ndarray, nd.push, ndm.push): 11019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid types. 11029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, {1,2,3}) 11039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,'3']) 11049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,(3,4)]) 11059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape={3}) 11069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], strides={1}) 11079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], offset=[]) 11089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], format={}) 11099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], flags={}) 11109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf={}) 11119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_FORTRAN flag is only valid without strides. 11139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], strides=[1], 11149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 11159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_PIL flag is only valid with ndim > 0. 11179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[], flags=ND_PIL) 11189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid items. 11209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [], shape=[1]) 11219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, ['XXX'], shape=[1], format="L") 11229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of items and format. 11239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [1000], shape=[1], format="B") 11249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,(2,3)], shape=[2], format="B") 11259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="QL") 11269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid ndim. 11289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM+1 11299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1]*n, shape=[1]*n) 11309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid shape. 11329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1], shape=[-1]) 11339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=['3']) 11349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[2**128]) 11359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # prod(shape) * itemsize != len(items) 11369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4,5], shape=[2,2], offset=3) 11379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid strides. 11399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], strides=['1']) 11409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[1], 11419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[2**128]) 11429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and shape. 11449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2], shape=[2,1], strides=[1]) 11459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and format. 11469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4], shape=[2], strides=[3], 11479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid offset. 11509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], offset=4) 11519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[1], offset=3, 11529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid format. 11559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="") 11569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [(1,2,3)], shape=[1], 11579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="@#$") 11589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Striding out of the memory bounds. 11609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10] 11619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, items, shape=[2,3], 11629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[-3, -2], offset=5) 11639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing consumer: format argument invalid. 11659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, bytearray(), format="Q") 11669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing original base object: getbuf argument invalid. 11689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf=PyBUF_FULL) 11699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Shape argument is mandatory for original base objects. 11719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1]) 11729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_WRITABLE request to read-only provider. 11759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, b'123', getbuf=PyBUF_WRITABLE) 11769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT can only be specified during construction. 11789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1], flags=ND_VAREXPORT) 11799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.push, [1], [1], flags=ND_VAREXPORT) 11809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid operation for consumers: push/pop 11829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(b'123') 11839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT not set: push/pop fail with exported buffers 11879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 11889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1], [1]) 11899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 11909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 11939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() 11949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Single remaining buffer: pop fails 11969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 11989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_pointer() 12009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, {}, [1,2,3]) 12019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, b'123', {}) 12029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(100)), shape=[1]*100) 12049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [5]) 12059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 12079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [2,3,4]) 12089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [3,3]) 12099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [-3,3]) 12109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_pointer, nd, [1<<64,3]) 12119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # tolist() needs format 12139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format='L') 12149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 12159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.tolist) 12169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview_from_buffer() 12189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray([1,2,3], shape=[3], format='L') 12199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(ex1) 12209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex2) 12219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([(1,)*200], shape=[1], format='L'*200) 12249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM 12279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(n)), shape=[1]*n) 12289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 12299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_contiguous() 12319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, 1, 2, 3, 4, 5) 12339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, "xyz", 'C') 12349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_contiguous, nd, 2**64, 'C') 12359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, PyBUF_READ, 961) 12369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(UnicodeEncodeError, get_contiguous, nd, PyBUF_READ, 12379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '\u2007') 123866e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'Z') 123966e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, 255, 'A') 12409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cmp_contig() 12429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, 1, 2, 3, 4, 5) 12449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, {}, nd) 12459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, nd, {}) 12469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is_contiguous() 12489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, 1, 2, 3, 4, 5) 12509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, {}, 'A') 12519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, nd, 201) 12529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_linked_list(self): 12549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for perm in permutations(range(5)): 12559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = [0]*5 12569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 12579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = memoryview(nd) 12589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(1, 5): 12609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1,2,3], shape=[3]) 12619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = memoryview(nd) 12629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 12649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[perm[i]].release() 12659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 12679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 12689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_scalar(self): 12709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0: scalar 12719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, scalar, _ in iter_format(0): 12729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(scalar, shape=(), format=fmt) 12749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 12779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=scalar) 12789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_shape(self): 12809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, shape = [n] 12819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 10) 12829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 12839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 12859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[nitems], format=fmt, flags=flags) 12869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=(nitems,), strides=(itemsize,), 12899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items) 12909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_strides(self): 12929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, strides 12939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 30) 12949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 12959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for step in range(-5, 5): 12979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if step == 0: 12989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 12999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [len(items[::step])] 13019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [step*itemsize] 13029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = itemsize*(nitems-1) if step < 0 else 0 13039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 13059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, strides=strides, 13069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format=fmt, offset=offset, flags=flags) 13079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=shape, strides=strides, 13109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items[::step]) 13119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_fortran(self): 13139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 13149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=(3, 4), strides=(1, 3)) 13159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_F_CONTIGUOUS|PyBUF_FORMAT) 13169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), farray(items, (3, 4))) 13179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_multidim(self): 13199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ndim in range(5): 13209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = [randrange(2, 10) for _ in range(ndim)] 13219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 13229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 13239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 13259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 13269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 13289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim == 0 and flags == ND_PIL: 13299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 13309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 13329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 13339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'C') 13359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 13369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 13429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: reconstruct strides 13439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 13449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 13459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nd.strides == ()) 13469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 13479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=None, 13489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 13539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 13549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 13559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'F') 13579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 13589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_invalid(self): 13649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # not writable 13659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 13669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 1, 8) 13679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, 8) 13709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot be deleted 13729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__delitem__, 1) 13749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__delitem__, 1) 13779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # overflow 13799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__getitem__, 1<<64) 13819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__setitem__, 1<<64, 8) 13829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 1<<64) 13859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 1<<64, 8) 13869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format 13889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 13899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="B", flags=ND_WRITABLE) 13909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 2, 300) 13919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 1, (100, 200)) 13929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__setitem__, 2, 300) 13959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, (100, 200)) 13969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [(1,2), (3,4), (5,6)] 13989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="LQ", flags=ND_WRITABLE) 13999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 2, 300) 14009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 1, (b'\x001', 200)) 14019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_scalar(self): 14039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar 14049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=(), flags=ND_WRITABLE) 14059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[()]; self.assertEqual(x, 1) 14099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[...]; self.assertEqual(x.tolist(), nd.tolist()) 14109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[()]; self.assertEqual(x, 1) 14129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[...]; self.assertEqual(x.tolist(), nd.tolist()) 14139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, 0) 14159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, 0) 14169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 0, 8) 14179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 0, 8) 14189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 1) 14209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), 1) 14219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9; self.assertEqual(nd.tolist(), 9) 14239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[()] = 9; self.assertEqual(mv.tolist(), 9) 14249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[...] = 5; self.assertEqual(nd.tolist(), 5) 14269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[...] = 5; self.assertEqual(mv.tolist(), 5) 14279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_null_strides(self): 14299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*4)), shape=[2, 4], flags=ND_WRITABLE) 14309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG) 14319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Sub-views are only possible for full exporters. 14339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, 1) 14349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Same for slices. 14359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, slice(3,5,1)) 14369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_single(self): 14389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem 14399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 14419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, -6) 14459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, 5) 14469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, -6) 14549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 5) 14559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null strides 14579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], flags=ND_WRITABLE, format=fmt) 14599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG|PyBUF_FORMAT) 14609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 14669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mv.__eq__(nd), NotImplemented) 14679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null format 14719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO) 14749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null shape/strides/format 14789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 14819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_setitem_single(self): 14869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value 14879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 14889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 14899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 14909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 14919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = single_item 14929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 14939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, -6, single_item) 14959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, 5, single_item) 14969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 14989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 14999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 15049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 15059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = single_item 15069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 15079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, -6, single_item) 15099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 5, single_item) 15109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value: lobject = robject 15139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 15149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = nd[i+1] 15189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 15199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 15219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 15229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = mv[i+1] 15299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 15309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_multidim(self): 15329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 15339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 15349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 15359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 15379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 15399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 15409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 15419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 15429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(-shape[2], shape[2]): 15489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 15519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 15529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 15539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 15549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(shape[2], shape[2]): 15609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_sequence(self): 15639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=()) 15649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in nd", locals()) 15659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in mv", locals()) 15689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 15709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 15719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(nd): 15729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in nd) 15749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 15769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(mv): 15789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in mv) 15809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_invalid(self): 15829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 15839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 15859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 15879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, xl.__setitem__, slice(0,8,1), items) 15889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, ml.__setitem__, slice(0,8,1), items) 15899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not a full exporter 15919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], flags=ND_WRITABLE) 15939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(ex, getbuf=PyBUF_ND) 15949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, xl.__setitem__, slice(0,8,1), xr) 15959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 15979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[8], format="L", flags=ND_WRITABLE) 15989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, slice(0,1,0)) 16009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__getitem__, slice(0,1,0)) 16019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[2,4], format="L", flags=ND_WRITABLE) 16039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 16049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 16069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 16079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 16089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,0), slice(0,1,1))) 16099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, "@%$") 16109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, ("@%$", slice(0,1,1))) 16119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, (slice(0,1,1), {})) 16129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: not implemented 16149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, mv.__getitem__, 16159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 16169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, "@%$") 16179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing format 16199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing itemsize 16299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray(items, shape=[8], format="L") 16319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing ndim 16399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[2, 4], format="b", flags=ND_WRITABLE) 16409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), [[1,2,3,4], [5,6,7,8]]) 16459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, ml.__setitem__, slice(0,1,1), 16469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr[7:8]) 16479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing shape 16499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="b", flags=ND_WRITABLE) 16509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,2,1), xr[7:8]) 16549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,2,1), mr[7:8]) 16569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # _testbuffer.c module functions 16599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, slice(0,1,2), {}) 16609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, "###########", 1) 16619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, slice_indices, slice(0,1,0), 4) 16629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[8], format="b", flags=ND_PIL) 16649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], format="B") 16679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(ex, getbuf=PyBUF_SIMPLE) 16689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_zero_shape(self): 16719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 16729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[12], format="L", flags=ND_WRITABLE) 16749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[12], format="L") 16759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[4:4] = y[9:9] 16769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), items) 16779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(x) 16799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(y) 16809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, x) 16819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, y) 16829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml[4:4] = mr[9:9] 16839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[3, 4], format="L", flags=ND_WRITABLE) 16869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[4, 3], format="L") 16879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[1:2, 2:2] = y[1:2, 3:3] 16889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), carray(items, [3, 4])) 16899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_multidim(self): 16919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 16929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 16939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 16949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 16959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 16979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 16989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 17009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 17019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 17029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 17049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 17069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 17089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 17109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_redundant_suboffsets(self): 17239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5, 2) 17249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 17259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 17269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 17279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 17299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 17309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt) 17329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.add_suboffsets() 17339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 17349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex.add_suboffsets() 17359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 17379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 17399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 17419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 17439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 17459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_single(self): 17589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 17599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(5): 17609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(5): 17619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 17629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f = flags|ND_WRITABLE 17649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=f) 17659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], format=fmt, flags=f) 17669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = None 17699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = None 17709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = items[:] 17719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lval = lst[lslice] 17739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rval = lst[rslice] 17749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[lslice] = lst[rslice] 17759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = len(lval) != len(rval) 17769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = e.__class__ 17789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslice] = nd[rslice] 17829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # ndarray cannot change shape 17869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, ValueError) 17879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), lst) 17899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, lsterr) 17909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 17929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 17939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = None 17959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[lslice] = mv[rslice] 17979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = e.__class__ 17999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # memoryview cannot change shape 18019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, ValueError) 18029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 18039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), lst) 18049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 18059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, lsterr) 18069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=ex, 18079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=nd.itemsize, fmt=fmt, readonly=0, 18089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=nd.ndim, shape=nd.shape, strides=nd.strides, 18099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=nd.tolist()) 18109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_multidim(self): 18129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 18139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 18149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 18159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 18169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 18189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 18209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices, rslices = randslice_from_shape(ndim, shape) 18229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 18249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_WRITABLE) 18259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 18269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 18289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah result = multislice_assign(lst, lst, lslices, rslices) 18309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 18329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 18349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslices] = nd[rslices] 18369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 18389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 18409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 18419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 18429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), result) 18439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random(self): 18459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # construction of valid arrays 18469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, True, maxdim=MAXDIM, 18519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*t)) 18539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 18549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 18569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xlist = x.tolist() 18579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(x) 18599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, xlist) 18629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if t[2] > 0: 18649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 18659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray_from_structure(items, fmt, t, flags=ND_PIL) 18669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ylist = y.tolist() 18679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xlist, ylist) 18689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(y) 18709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, y) 18729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, ylist) 18749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 18769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = t[3] 18779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in shape: 18789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 18799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah z = numpy_array_from_structure(items, fmt, t) 18809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(x, obj=None, 18819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=z.itemsize, fmt=fmt, readonly=0, 18829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=z.ndim, shape=z.shape, strides=z.strides, 18839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=z.tolist()) 18849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_invalid(self): 18869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # exceptions during construction of invalid arrays 18879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, False, maxdim=MAXDIM, 18929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(verify_structure(*t)) 18949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 18959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = False 18979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 18999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 19009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 19019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nderr) 19029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 19049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = False 19059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 19069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = numpy_array_from_structure(items, fmt, t) 19079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 19089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = e.__class__ 19099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0: # http://projects.scipy.org/numpy/ticket/1910 19119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(numpy_err) 19129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_slice_assign(self): 19149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # valid slice assignments 19159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 19169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 19179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 19189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape, rshape, lslices, rslices = \ 19209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rand_aligned_slices(maxdim=MAXDIM, maxshape=MAXSHAPE) 19219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tl = rand_structure(itemsize, True, shape=lshape) 19229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tr = rand_structure(itemsize, True, shape=rshape) 19239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tl)) 19249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tr)) 19259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah litems = randitems_from_structure(fmt, tl) 19269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ritems = randitems_from_structure(fmt, tr) 19279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray_from_structure(litems, fmt, tl) 19299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray_from_structure(ritems, fmt, tr) 19309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl[lslices] = xr[rslices] 19319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xllist = xl.tolist() 19329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xrlist = xr.tolist() 19339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 19359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 19369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), xllist) 19379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), xrlist) 19389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if tl[2] > 0 and tr[2] > 0: 19409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 19419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl = ndarray_from_structure(litems, fmt, tl, flags=ND_PIL) 19429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray_from_structure(ritems, fmt, tr, flags=ND_PIL) 19439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl[lslices] = yr[rslices] 19449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yllist = yl.tolist() 19459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yrlist = yr.tolist() 19469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xllist, yllist) 19479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xrlist, yrlist) 19489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(yl) 19509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(yr) 19519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), yllist) 19529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), yrlist) 19539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 19559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in lshape or 0 in rshape: 19569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 19579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl = numpy_array_from_structure(litems, fmt, tl) 19599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zr = numpy_array_from_structure(ritems, fmt, tr) 19609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl[lslices] = zr[rslices] 19619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_overlapping(tl) and not is_overlapping(tr): 19639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Slice assignment of overlapping structures 19649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is undefined in NumPy. 19659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xl, obj=None, 19669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zl.itemsize, fmt=fmt, readonly=0, 19679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zl.ndim, shape=zl.shape, 19689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zl.strides, lst=zl.tolist()) 19699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xr, obj=None, 19719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zr.itemsize, fmt=fmt, readonly=0, 19729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zr.ndim, shape=zr.shape, 19739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zr.strides, lst=zr.tolist()) 19749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_re_export(self): 19769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 19779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[3,4], flags=ND_PIL) 19799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(nd) 19809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.flags & ND_PIL) 19829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(ex.obj, nd) 19839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ex.suboffsets, (0, -1)) 19849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 19859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.f_contiguous) 19869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.contiguous) 19879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_shape(self): 19899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 19909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 19919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0], flags=flags) 19929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 19939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 19949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 19959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), []) 19969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0,3,3], flags=flags) 19989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 19999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,0,3], flags=flags) 20019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [[], [], []]) 20029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,3,0], flags=flags) 20049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 20059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [[[], [], []], [[], [], []], [[], [], []]]) 20069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_strides(self): 20089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero strides 20099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[5], strides=[0], flags=flags) 20119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 20129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 20139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [1, 1, 1, 1, 1]) 20149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), [1, 1, 1, 1, 1]) 20159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_offset(self): 20179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(20)), shape=[3], offset=7) 20189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.offset, 7) 20199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [7,8,9]) 20209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_memoryview_from_buffer(self): 20229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 20259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 20269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_get_pointer(self): 20289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(3): 20319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], get_pointer(nd, [i])) 20329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_tolist_null_strides(self): 20349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(20)), shape=[2,2,5]) 20359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_ND|PyBUF_FORMAT) 20379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), ex.tolist()) 20389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 20409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 20419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_cmp_contig(self): 20439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(b"123", b"456")) 20459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(list(range(12)), shape=[3,4]) 20479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(list(range(12)), shape=[4,3]) 20489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(x, y)) 20499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1], shape=[1], format="B") 20519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(x, b'\x01')) 20529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(b'\x01', x)) 20539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_hash(self): 20559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1,2,3]) 20579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(a) 20589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, hash, nd) 20599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 20619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12]) 20649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 20679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 20689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,2,2]) 20719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 20749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[4,3])) 20759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4], flags=ND_FORTRAN) 20769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[2,3,2])) 20799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], flags=ND_FORTRAN) 20809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # suboffsets 20839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], flags=ND_PIL) 20859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 20889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 20899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(nd.tobytes())) 20909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah def test_py_buffer_to_contiguous(self): 20927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 20937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # The requests are used in _testbuffer.c:py_buffer_to_contiguous 20947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # to generate buffers without full information for testing. 20957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah requests = ( 20967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # distinct flags 20977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 20987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # compound requests 20997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL, PyBUF_FULL_RO, 21007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 21017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 21027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 21037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ) 21047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # no buffer interface 21067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertRaises(TypeError, py_buffer_to_contiguous, {}, 'F', 21077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL_RO) 21087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # scalar, read-only request 21107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 21117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 21157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # zeros in shape 21177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 21187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 21247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 21257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### One-dimensional arrays are trivial, since Fortran and C order 21317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### are the same. 21327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional 21347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 21357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[1], format="h", flags=f|ND_WRITABLE) 21367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=f|ND_WRITABLE) 21437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional, non-contiguous input 21507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 21517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_STRIDES, PyBUF_FULL]: 21547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = nd[::-1] 21587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 21627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 21647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 21657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Multi-dimensional arrays: 21697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The goal here is to preserve the logical representation of the 21717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### input array but change the physical representation if necessary. 21727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer example: 21747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ==================== 21757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input array: 21777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------------- 21787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(list(range(12)), shape=[3, 4]) 21797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 21817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 21827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 21837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 21857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 21867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 21877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 21887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The return value corresponds to this input list for 21907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray: 21917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray([0,4,8,1,5,9,2,6,10,3,7,11], shape=[3,4], 21927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### flags=ND_FORTRAN) 21937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 21957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 21967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 21977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The logical array is the same, but the values in memory are now 21997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### in Fortran order. 22007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### NumPy example: 22027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ============== 22037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray takes lists to initialize the memory. 22047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Here's the same sequence in NumPy: 22057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input: 22077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------- 22087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=bytearray(list(range(12))), 22097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### shape=[3, 4], dtype='B') 22107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 22117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 22127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 22137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 22167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 22177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf = nd.tostring(order='F') 22187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf 22197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 22207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=fortran_buf, shape=[3, 4], 22227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### dtype='B', order='F') 22237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 22257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 22267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 22277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, contiguous input 22317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah lst = list(range(12)) 22327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 22337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(lst, shape=[3, 4], flags=f|ND_WRITABLE) 22347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah na = numpy_array(buffer=bytearray(lst), 22367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah shape=[3, 4], dtype='B', 22377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah order='C' if f == 0 else 'F') 22387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' request 22407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: # 'F' to 'C' 22417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [4, 3]), shape=[3, 4], 22427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 22477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', request) 22497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a C array that is logically identical to the input array. 22567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 22577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='C')) 22617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' request 22637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == 0: # 'C' to 'F' 22647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], 22657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', request) 22737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a Fortran array that is logically identical to the input array. 22797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 22807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='F')) 22847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' request 22867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: 22877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', request) 22957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 23017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # an array with order=f that is logically identical to the input 23027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # array. 23037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=f|ND_WRITABLE) 23047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 23077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='A')) 23087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, non-contiguous input 23107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 23117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' 23137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', PyBUF_FULL_RO) 23147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' 23197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 23207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], flags=ND_WRITABLE) 23217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, x.tobytes()) 23227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 23237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' 23267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', PyBUF_FULL_RO) 23277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_construction(self): 23329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_shape = [(9, []), ([1,2,3], [3]), (list(range(2*3*5)), [2,3,5])] 23349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, C-contiguous: 23369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 23409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 23429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'C') 23469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 23479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 23499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 23549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 23559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 23569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no strides 23619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 23629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no format, shape, strides 23709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 23719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.format, '') 23729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.shape, ()) 23739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [items] if ndim == 0 else items 23779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[ex.nbytes], strides=(1,), 23809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, Fortran contiguous: 23839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_FORTRAN) 23879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.f_contiguous) 23899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'F') 23939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 23949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 23969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 24019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 24029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 24039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 24059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PIL style: 24089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape[1:]: 24099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 24119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_PIL) 24129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 24139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 24159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 24169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 24189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 24239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 24249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 24259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid number of arguments: 24309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, b'9', 'x') 24319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not a buffer provider: 24329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, {}) 24339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Non-compliant buffer provider: 24349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3]) 24359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 24369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 24389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 64 24419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1]*128, shape=[1]*128, format='L') 24429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, nd) 24439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 24449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'C') 24459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'F') 24469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd[::-1], PyBUF_READ, 'C') 24479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_shape(self): 244960b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Casts are undefined if buffer is multidimensional and shape 245060b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # contains zeros. These arrays are regarded as C-contiguous by 245160b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Numpy and PyBuffer_GetContiguous(), so they are not caught by 245260b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # the test for C-contiguity in memory_cast(). 24539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3] 24549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in ([0,3,3], [3,0,3], [0,3,3]): 24559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 24569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.c_contiguous) 24579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 24589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 245960b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Monodimensional empty view can be cast (issue #19014). 246060b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou for fmt, _, _ in iter_format(1, 'memoryview'): 246160b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou msrc = memoryview(b'') 246260b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou m = msrc.cast(fmt) 246360b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou self.assertEqual(m.tobytes(), b'') 246460b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou self.assertEqual(m.tolist(), []) 24659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2466a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check_sizeof = support.check_sizeof 2467a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 2468a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou def test_memoryview_sizeof(self): 2469a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check = self.check_sizeof 2470a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou vsize = support.calcvobjsize 247163afdaa1105de24e87658e82de314a37d341f02bAntoine Pitrou base_struct = 'Pnin 2P2n2i5P P' 2472a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou per_dim = '3n' 2473a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 2474a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou items = list(range(8)) 2475a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(b''), vsize(base_struct + 1 * per_dim)) 2476a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou a = ndarray(items, shape=[2, 4], format="b") 2477a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(a), vsize(base_struct + 2 * per_dim)) 2478a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou a = ndarray(items, shape=[2, 2, 2], format="b") 2479a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(a), vsize(base_struct + 3 * per_dim)) 2480a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 24819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_struct_module(self): 24829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class INT(object): 24849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __int__(self): 24879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class IDX(object): 24909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __index__(self): 24939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def f(): return 7 24969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah values = [INT(9), IDX(9), 24989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2.2+3j, Decimal("-21.1"), 12.2, Fraction(5, 2), 24999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1,2,3], {4,5,6}, {7:8}, (), (9,), 25009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah True, False, None, NotImplemented, 25019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b'a', b'abc', bytearray(b'a'), bytearray(b'abc'), 25029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'a', 'abc', r'a', r'abc', 25039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f, lambda x: x] 25049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, item in iter_format(10, 'memoryview'): 25069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 25079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 25089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, 0, item) 25119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = item 25129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[0], nd[0]) 25139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 25159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 'P' in fmt: 25169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 25179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in values: 25199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = None 25209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 25219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, itemsize, v) 25229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 25239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = struct.error 25249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = None 25269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 25279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = v 25289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except (TypeError, ValueError) as e: 25299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = e.__class__ 25309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if struct_err or mv_err: 25329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(struct_err, None) 25339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(mv_err, None) 25349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 25359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], nd[1]) 25369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_strides(self): 25389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Casts are undefined if strides contains zeros. These arrays are 25399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # (sometimes!) regarded as C-contiguous by Numpy, but not by 25409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBuffer_GetContiguous(). 25419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], strides=[0]) 25429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 25439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 25459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_invalid(self): 25479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid format 25489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt in NON_BYTE_FORMAT: 25499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sformat = '@' + sfmt if randrange(2) else sfmt 25509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ssize = struct.calcsize(sformat) 25519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt in NON_BYTE_FORMAT: 25529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dformat = '@' + dfmt if randrange(2) else dfmt 25539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dsize = struct.calcsize(dformat) 25549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(32)), shape=[32//ssize], format=sformat) 25559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, [32//dsize]) 25579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt, sitems, _ in iter_format(1): 25599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(sitems, shape=[1], format=sfmt) 25609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt, _, _ in iter_format(1): 25620c51595a784787d8e198af910cb6d79172ee52bbStefan Krah if not is_memoryview_format(dfmt): 25639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, msrc.cast, dfmt, 25649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 25669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_byte_format(sfmt) and not is_byte_format(dfmt): 25679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, 25689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid shape 25719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_h = struct.calcsize('h') 25729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_d = struct.calcsize('d') 25739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*2*size_d)), shape=[2,2,size_d], format='h') 25749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, shape=[2,2,size_h], format='d') 25769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 25789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect number of args 25819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast) 25829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, 1, 2, 3) 25839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format type 25859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, {}) 25869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format 25889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "X") 25899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@X") 25909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@XY") 25919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # dest format not implemented 25939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "=B") 25949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "!L") 25959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "<P") 25969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, ">l") 25979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "BI") 25989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "xBI") 25999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # src format not implemented 26019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(1,2), (3,4)], shape=[2], format="II") 26029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 26049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 8) 26059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 26069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape type 26089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 26099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape={}) 26119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape elements 26139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[2*3*4*5]) 26149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, m.cast, "B", shape=[2**64]) 26169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[-1]) 26179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,-1]) 26189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,0]) 26199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5,6,7,'x']) 26209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # N-D -> N-D cast 26229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3,5,7,11]) 26239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5]) 26259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast with ndim > 64 26279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 26289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 26299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'I', [1]*128) 26309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # view->len not a multiple of itemsize 26329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3*5*7*11]) 26339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5]) 26359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize != buffer size 26379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3*5*7*11]) 26389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5]) 26409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize overflow 26429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 26439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 26449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='B') 26459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 26469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if sys.maxsize == 2**63-1: 26479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [7, 7, 73, 127, 337, 92737, 649657]) 26499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**3]) 26519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**1]) 26539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 26549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1, 2147483647]) 26569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**5, 2**1]) 26589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**3, 2**1]) 26609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast(self): 26629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytespec = ( 26639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('B', lambda ex: list(ex.tobytes())), 26649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('b', lambda ex: [x-256 if x > 127 else x for x in list(ex.tobytes())]), 26659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('c', lambda ex: [bytes(chr(x), 'latin-1') for x in list(ex.tobytes())]), 26669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 26679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def iter_roundtrip(ex, m, items, fmt): 26699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize(fmt) 26709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bytefmt, to_bytelist in bytespec: 26719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(bytefmt) 26739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = to_bytelist(ex) 26749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt=bytefmt, readonly=0, 26769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31*srcsize], strides=(1,), 26779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 26809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m3, ex) 26819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 26829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, obj=ex, 26839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=srcsize, fmt=fmt, readonly=0, 26849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31], strides=(srcsize,), 26859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 0 to ndim = 1 26889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize('I') 26899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9, shape=[], format='I') 26909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'B', 1) 26919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('B') 26939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 26959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=destshape, strides=(1,), 26969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 26979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 1 to ndim = 0 26999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destsize = struct.calcsize('I') 27009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([9]*destsize, shape=[destsize], format='B') 27019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'I', destsize, shape=[]) 27029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('I', shape=[]) 27049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 27059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=destsize, fmt='I', readonly=1, 27069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 27079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 27089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # array.array: roundtrip to/from bytes 27109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'array'): 27119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, items) 27129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 27149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray: roundtrip to/from bytes 27169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'memoryview'): 27179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[31], format=fmt, flags=ND_WRITABLE) 27189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 27209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_1D_ND(self): 27229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Cast between C-contiguous buffers. At least one buffer must 27239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # be 1D, at least one format must be 'c', 'b' or 'B'. 27249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _tshape in gencastshapes(): 27259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@']: 27269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tfmt = ('', '@')[randrange(2)] + char 27279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tsize = struct.calcsize(tfmt) 27289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = prod(_tshape) * tsize 27299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah obj = 'memoryview' if is_byte_format(tfmt) else 'bytefmt' 27309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(n, obj): 27319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize(fmt) 27329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [n] if n > 0 else [] 27339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tshape = _tshape + [size] 27349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 27369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah titems, tshape = cast_items(ex, tfmt, tsize, shape=tshape) 27399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems is None: 27419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, tfmt, tshape) 27429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 27439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems == 'nan': 27449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # NaNs in lists are a recipe for trouble. 27459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # 1D -> ND 27479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(titems, shape=tshape, format=tfmt) 27489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(tfmt, shape=tshape) 27509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(tshape) 27519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = nd.strides 27529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 27539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 27549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=tsize, fmt=tfmt, readonly=1, 27559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=tshape, strides=strides, 27569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND -> 1D 27599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 27609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m4 = m2.cast(fmt, shape=shape) 27619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 27629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = ex.strides 27639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 27649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, obj=ex, 27669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=size, fmt=fmt, readonly=1, 27679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 27689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m4, obj=ex, 27719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=size, fmt=fmt, readonly=1, 27729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 27739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27750c51595a784787d8e198af910cb6d79172ee52bbStefan Krah if ctypes: 27760c51595a784787d8e198af910cb6d79172ee52bbStefan Krah # format: "T{>l:x:>d:y:}" 27770c51595a784787d8e198af910cb6d79172ee52bbStefan Krah class BEPoint(ctypes.BigEndianStructure): 27780c51595a784787d8e198af910cb6d79172ee52bbStefan Krah _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_double)] 27790c51595a784787d8e198af910cb6d79172ee52bbStefan Krah point = BEPoint(100, 200.1) 27800c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m1 = memoryview(point) 27810c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m2 = m1.cast('B') 27820c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.obj, point) 27830c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.itemsize, 1) 27840c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.readonly, 0) 27850c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.ndim, 1) 27860c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.shape, (m2.nbytes,)) 27870c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.strides, (1,)) 27880c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.suboffsets, ()) 27890c51595a784787d8e198af910cb6d79172ee52bbStefan Krah 27900c51595a784787d8e198af910cb6d79172ee52bbStefan Krah x = ctypes.c_double(1.2) 27910c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m1 = memoryview(x) 27920c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m2 = m1.cast('c') 27930c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.obj, x) 27940c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.itemsize, 1) 27950c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.readonly, 0) 27960c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.ndim, 1) 27970c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.shape, (m2.nbytes,)) 27980c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.strides, (1,)) 27990c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.suboffsets, ()) 28000c51595a784787d8e198af910cb6d79172ee52bbStefan Krah 28019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tolist(self): 28029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Most tolist() tests are in self.verify() etc. 28049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('h', list(range(-6, 6))) 28069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 28079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 28089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 28099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = a[2::3] 28119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = m[2::3] 28129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 28139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 28149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*3*5*7*11)), shape=[11,2,7,3,5], format='L') 28169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 28189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(2, 5), (7, 11)], shape=[2], format='lh') 28209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s") 28249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b"a",b"b",b"c",b"d",b"e",b"f"], shape=[2,3], format='s') 28289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_repr(self): 28329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(bytearray(9)) 28339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 28349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<memory")) 28359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 28379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 28389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<released")) 28399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_sequence(self): 28419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in ('d', 'f'): 28439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah inf = float(3e400) 28449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, [1.0, inf, 3.0]) 28459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(1.0, m) 28479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(5e700, m) 28489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(3.0, m) 28499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9.0, [], format='f') 28519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "9.0 in m", locals()) 28539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 285431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou @contextlib.contextmanager 285531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou def assert_out_of_bounds_error(self, dim): 285631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assertRaises(IndexError) as cm: 285731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou yield 285831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(str(cm.exception), 285931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou "index out of bounds on dimension %d" % (dim,)) 286031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 28619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_index(self): 28629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 28649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='d') 28659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 12.5) 28679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], m) 28689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], ex) 28699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0) 28709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray((1,2,3), shape=[], format='iii') 28729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, ()) 28749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 28769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 28779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 2**64) 28809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 2.0) 28819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0.0) 28829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 28849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, -8) 28859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 8) 28869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 288731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # multi-dimensional 28889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 28899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 289131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[0, 0], 0) 289231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[2, 0], 8) 289331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[2, 3], 11) 289431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[-1, -1], 11) 289531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[-3, -4], 0) 289631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 289731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # out of bounds 289831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (3, -4): 289931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=1): 290031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[index, 0] 290131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (4, -5): 290231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=2): 290331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0, index] 290431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__getitem__, (2**64, 0)) 290531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__getitem__, (0, 2**64)) 290631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 290731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__getitem__, (0, 0, 0)) 290831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__getitem__, (0.0, 0.0)) 290931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 291031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # Not implemented: multidimensional sub-views 291131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(NotImplementedError, m.__getitem__, ()) 29129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 29139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_assign(self): 29159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 29179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='f', flags=ND_WRITABLE) 29189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 22.5 29209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 22.5) 29219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[...] = 23.5 29229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 23.5) 29239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 24.7) 29249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # read-only 29269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7]) 29279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2, 10) 29299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 29319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 29329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 2**64, 9) 29359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2.0, 10) 29369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0.0, 11) 29379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 29399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, -8, 20) 29409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 8, 25) 29419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() success: 29439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 29449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c' or fmt == '?': 29459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format=fmt, flags=ND_WRITABLE) 29479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah i = randrange(-3, 3) 29499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = 8 29509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], 8) 29519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], ex[i]) 29529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'1', b'2', b'3'], shape=[3], format='c', 29549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 29559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[2] = b'9' 29579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[2], b'9') 29589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([True, False, True], shape=[3], format='?', 29609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 29619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = True 29639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], True) 29649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() exceptions: 29669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([b'x'], shape=[1], format='c', flags=ND_WRITABLE) 29679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 29689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 100) 29699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5], flags=ND_WRITABLE) 29719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex) 29729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, _range in fmtdict['@'].items(): 29749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (fmt == '?'): # PyObject_IsTrue() accepts anything 29759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c': # special case tested above 29779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast(fmt) 29799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = _range 29809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'd' or fmt == 'f': 29819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = -2**1024, 2**1024 29829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt != 'P': # PyLong_AsVoidPtr() accepts negative numbers 29839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, lo-1) 29849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m2.__setitem__, 0, "xyz") 29859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, hi) 29869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid item 29889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast('c') 29899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, b'\xff\xff') 29909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format not implemented 29929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(1)), shape=[1], format="xL", flags=ND_WRITABLE) 29939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 29959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s", flags=ND_WRITABLE) 29979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 29999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 300031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # multi-dimensional 30019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 30029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 300331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0,1] = 42 300431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(ex[0][1], 42) 300531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[-1,-1] = 43 300631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(ex[2][3], 43) 300731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # errors 300831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (3, -4): 300931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=1): 301031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[index, 0] = 0 301131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (4, -5): 301231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=2): 301331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0, index] = 0 301431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__setitem__, (2**64, 0), 0) 301531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__setitem__, (0, 2**64), 0) 301631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 301731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__setitem__, (0, 0, 0), 0) 301831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__setitem__, (0.0, 0.0), 0) 30199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 302031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # Not implemented: multidimensional sub-views 30219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, [2, 3]) 30229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_slice(self): 30249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 30269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 30299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, slice(0,2,0)) 30309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, slice(0,2,0), 30319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 30329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 303331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # 0-dim slicing (identity function) 303431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(NotImplementedError, m.__getitem__, ()) 30359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multidimensional slices 30379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 30389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 30419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1))) 30429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 30439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1)), bytearray([1,2])) 30449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slice tuple 30469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, (slice(0,2,1), {})) 30479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, (slice(0,2,1), {}), 30489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 30499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 30519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, slice(0,1,1), [1]) 30529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous slice assignment 30549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 30559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(12)), shape=[12], strides=[-1], offset=11, 30569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|flags) 30579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(24)), shape=[12], strides=[2], flags=flags) 30589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 30599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 30609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[2:5] = ex1[2:5] 30629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[2:5] = m2[2:5] 30639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[1:3][::-1] = ex2[0:2][::1] 30689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[1:3][::-1] = m2[0:2][::1] 30699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[4:1:-2][::-1] = ex1[1:4:2][::1] 30749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[4:1:-2][::-1] = m1[1:4:2][::1] 30759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_array(self): 30809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def cmptest(testcase, a, b, m, singleitem): 30829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, _ in enumerate(a): 30839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ai = a[i] 30849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mi = m[i] 30859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(ai, mi) 30869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = singleitem 30879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if singleitem != ai: 30889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, m) 30899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, b) 30909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 30919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 30929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, b) 30939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = singleitem 30949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 30959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(b, m) 30969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = ai 30979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = mi 30989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(1, 5): 31009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, singleitem in iter_format(n, 'array'): 31019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(n): 31029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(n): 31039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array(fmt, items) 31059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array(fmt, items) 31069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 31079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 31099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 31109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 31119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), len(a)) 31129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 31149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = None 31169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = None 31179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 31189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah al = a[lslice] 31199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ar = a[rslice] 31209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[lslice] = a[rslice] 31219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = len(al) != len(ar) 31229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 31239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = e.__class__ 31249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = None 31269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 31279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[lslice] = m[rslice] 31289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 31299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = e.__class__ 31309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if have_resize: # memoryview cannot change shape 31329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, ValueError) 31339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif m_err or array_err: 31349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, array_err) 31359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 31369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 31379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 31389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 31399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 31409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 314106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_special_cases(self): 31429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1, 2, 3]) 31449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('L', [1, 2, 7]) 31459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Ordering comparisons raise: 31479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(b) 31499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('__lt__', '__le__', '__gt__', '__ge__'): 31509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(v, attr)(w), NotImplemented) 31519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(a, attr)(v), NotImplemented) 31529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Released views compare equal to themselves: 31549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v.release() 31569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, v) 31579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 31589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 31599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(a) 31629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w.release() 31639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 31649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 31659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Operand does not implement the buffer protocol: 31679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, [1, 2, 3]) 31699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 317006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # NaNs 317106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([(0, 0)], shape=[1], format='l x d x', flags=ND_WRITABLE) 317206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd[0] = (-1, float('nan')) 317306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(memoryview(nd), nd) 31749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 317506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Depends on issue #15625: the struct module does not understand 'u'. 317606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = array.array('u', 'xyz') 31779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 31799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 31809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 318106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Some ctypes format strings are unknown to the struct module. 318206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 318306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 318406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 318506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 318606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 318706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 318806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(point) 318906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 319006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, point) 319106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(point, a) 319206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertRaises(NotImplementedError, a.tolist) 319306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 319406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_zero(self): 31959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(1729, shape=[], format='@L') 31979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(1729, shape=[], format='L', flags=ND_WRITABLE) 31989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 31999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 32019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, v) 32029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 32039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd2, v) 32049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 32059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd1, w) 32069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__ne__(w)) 32089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__ne__(v)) 32099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w[()] = 1728 32119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 32129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 32139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 32149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd2, v) 32159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 32169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd1, w) 32179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__eq__(w)) 32199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__eq__(v)) 32209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 32229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 32239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 32249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 32269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[9] = 100 32279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m, nd) 32289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 322906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: equal 323006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 323106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((1729, 1.2, b'12345'), shape=[], format='hf5s', 323206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 323306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 323406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 323506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 323606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, v) 323706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 323806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd2, v) 323906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 324006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd1, w) 324106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 324206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: not equal 324306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 324406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((-1729, 1.2, b'12345'), shape=[], format='hf5s', 324506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 324606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 324706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 324806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 324906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, v) 325006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 325106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd2, v) 325206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 325306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd1, w) 325406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 325506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 325606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 325706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_one(self): 325806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 325906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous 32609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 32619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='@h') 32629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 32669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 32679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 32689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 32699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 32709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 327106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous, struct module 327206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<i') 327306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='>h') 327406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 327506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 327606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 327706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 327806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 327906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 328006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 328106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 328206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 328306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous 32849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 32859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 32869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 32909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 32919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 32929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 32939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 329406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, struct module 329506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='!h') 329606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<l') 329706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 329806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 329906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 330106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 330206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 330306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 330406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets 33069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 33079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h', 33089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_PIL) 33099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 33139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 33149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 33159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 33169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 331706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets, struct module 331806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='h 0c') 331906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='> h', 332006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 332106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 332206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 332306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 332406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 332506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 332606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 332706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 332806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 332906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_shape(self): 333006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 333106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 33329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 961], shape=[0], format='@h') 33339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-900, -961], shape=[0], format='@h') 33349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 33409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 33419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 33429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 334306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 334406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([900, 961], shape=[0], format='= h0c') 334506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-900, -961], shape=[0], format='@ i') 334606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 334706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 334806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 334906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 335006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 335106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 335206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 335306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 335406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 335506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_strides(self): 335606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 335706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 33589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 900, 900, 900], shape=[4], format='@L') 33599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4], strides=[0], format='L') 33609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 33669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 33679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 33689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 336906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 337006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(900, 900)]*4, shape=[4], format='@ Li') 337106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(900, 900)], shape=[4], strides=[0], format='!L h') 337206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 337306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 337406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 337506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 337606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 337706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 337806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 337906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 338006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 338106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_random_formats(self): 338206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 338306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random single character native formats 33849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 10 33859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@m']: 33869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, singleitem = randitems(n, 'memoryview', '@', char) 33879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 33889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[n], format=fmt, flags=flags) 33899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 33909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 33919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-3] 33939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 33949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 33959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 339606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random formats 339706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan n = 10 339806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for _ in range(100): 339906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan fmt, items, singleitem = randitems(n) 340006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for flags in (0, ND_PIL): 340106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(items, shape=[n], format=fmt, flags=flags) 340206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 340306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 340406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 340506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = nd[::-3] 340606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 340706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 340806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 340906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_c(self): 341006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 341106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values 34129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='@h') 34139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[3, 2, 5], format='@h') 34149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 342306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values, struct module 342406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*30, shape=[3, 2, 5], format='=f q xxL') 342506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1.2, 1, 2)]*30, shape=[3, 2, 5], format='< f 2Q') 342606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 342706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 342806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 342906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 343006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 343106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 343206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 343306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 343406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 343506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape 34369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 34379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='L') 34389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 344706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape, struct module 344806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*21, shape=[3, 7], format='! b B xL') 344906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(0, 1, 2)]*21, shape=[7, 3], format='= Qx l xxL') 34509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 345906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different format, struct module 346006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 346106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[2, 3, 5], format='l') 346206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 346306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 346406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 346506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 346606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 346706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 346806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 346906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 347006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 347106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_fortran(self): 347206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 347306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values 34749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[5, 2, 3], format='@h', 34759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[5, 2, 3], format='@h', 34779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 348706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values, struct module 348806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(2**64-1, -1)]*6, shape=[2, 3], format='=Qq', 348906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 349006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1, 2**64-1)]*6, shape=[2, 3], format='=qQ', 349106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 349206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 349306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 349406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 349506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 349606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 349706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 349806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 349906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 350006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 350106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape 35029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='l', 35039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 35059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 351506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape, struct module 351606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='0ll', 35179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 351806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 35199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 352906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different format, struct module 353006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[5, 2, 3], format='@h', 353106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 353206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 2, 3], format='@b', 353306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 353406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 353506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 353606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 353706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 353806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 353906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 354006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 354106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 354206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_mixed(self): 354406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous 35469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 35479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 35489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l') 35499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN) 35509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 35569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 355706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous, struct module 355806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(-3.3, -22, b'x')]*30 355906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[5] = (-2.2, -22, b'x') 356006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 356106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='d b c') 356206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='d h c', flags=ND_FORTRAN) 356306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 356406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 356506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 356606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 356706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 356806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 356906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 357006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different values, non-contiguous 35719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 35729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 35739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I') 35749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 35759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 358406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # same values, non-contiguous, struct module 358506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='=ii') 358606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 358706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='>ii') 358806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 358906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 359006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 359106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 359206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 359306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 359406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 359506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 359606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 359706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 35989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # different shape 35999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b') 36009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 36019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 36029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 36039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 361206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different shape, struct module 361306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='B') 36149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 361506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 36169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 36179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 362606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different format, struct module 362706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='b3s') 362806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 362906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='i3s') 363006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 363106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 363206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 363306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 363406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 363506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 363606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 363706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 363806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 363906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_shape(self): 364106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 364306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 364406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 364506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 364606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 364706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 364906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 365006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 365106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 365206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 365306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 365406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 36559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 36569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 36579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 366606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_strides(self): 366706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 366806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 36699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900]*80, shape=[4, 5, 4], format='@L') 36709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4, 5, 4], strides=[0, 0, 0], format='L') 36719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 36779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 36789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 36799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v.tolist(), w.tolist()) 36809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 368106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 368206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(1, 2)]*10, shape=[2, 5], format='=lQ') 368306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(1, 2)], shape=[2, 5], strides=[0, 0], format='<lQ') 368406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 368506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 368606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 368706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 368806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 368906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 369006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 369106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 369206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 369306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_suboffsets(self): 369406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 369506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets 36969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 36979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 36989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I', flags=ND_PIL) 36999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 37009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 370906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, struct module 371006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='=Qq', 371106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 371206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[2][7] = (1, -2) 371306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 371406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 371506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='>Qq', 371606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 371706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2[2][7] = (1, -2) 371806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 371906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 372106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 372206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 372406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 372506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 372606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 372706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 372806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape 373006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b', 373106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 37329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 37339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 37349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 37359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 374406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape, struct module 374506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**8-1, -1)]*40, shape=[2, 3, 5], format='Bb', 374606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 374706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:2:, ::-2] 374806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 374906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**8-1, -1)]*40, shape=[3, 2, 5], format='Bb') 375006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:2:, ::-2] 375106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 375206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 375306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 375406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 375506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 375606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 375706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 375806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 375906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 376006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 376106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format 37629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[5, 3, 2], format='i', flags=ND_PIL) 37639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 376406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray(list(range(30)), shape=[5, 3, 2], format='@I', flags=ND_PIL) 376506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 376606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 376706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 376806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 376906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 377006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 377106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 377206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 377306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 377406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 377506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format, struct module 377606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP', 377706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 377806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[1][2][2] = (b'sushi', b'', 1) 377906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 378006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 378106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP', 378206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 378306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[1][2][2] = (b'sushi', b'', 1) 37849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 378506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 37869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # initialize mixed C/Fortran + suboffsets 37969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 37979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 37989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l', flags=ND_PIL) 37999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN|ND_PIL) 38009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 38019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 38029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 38049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 38059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 38069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 380706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # initialize mixed C/Fortran + suboffsets, struct module 380806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(b'sashimi', b'sliced', 20.05)]*30 380906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[11] = (b'ramen', b'spicy', 9.45) 381006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 381106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 381206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='< 10p 9p d', flags=ND_PIL) 381306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='> 10p 9p d', 381406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN|ND_PIL) 381506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 381606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 381706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 381806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 381906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 382006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 382106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_not_equal(self): 382306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # items not equal 382506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for byteorder in ['=', '<', '>', '!']: 382606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q') 382706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q', 382806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE|ND_FORTRAN) 382906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = 1 383006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 383106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 383206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 383306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 383406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 383506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 383606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 383706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 383806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 383906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH') 384006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 384106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH', flags=ND_WRITABLE|ND_FORTRAN) 384206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = (1, 1, 1) 384306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 384406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 384506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 384606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 384706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 384806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 384906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 385006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 38519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_check_released(self): 38529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('d', [1.1, 2.2, 3.3]) 38549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 38569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 38579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromObject() 38599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, m) 38609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.cast() 38619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'c') 38629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getbuffer() 38639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ndarray, m) 38649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tolist() 38659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tolist) 38669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tobytes() 38679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tobytes) 38689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # sequence 38699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, eval, "1.0 in m", locals()) 38709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # subscript 38719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, 0) 38729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assignment 38739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, 0, 1) 38749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('obj', 'nbytes', 'readonly', 'itemsize', 'format', 'ndim', 38769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'shape', 'strides', 'suboffsets', 'c_contiguous', 38779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f_contiguous', 'contiguous'): 38789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getattribute__, attr) 38799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # richcompare 38819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('d', [1.1, 2.2, 3.3]) 38829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 38839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(b) 38849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m2) 38869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 38879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, m2) 38889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, a) 38899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m1) 38909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tobytes(self): 38929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 38939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 389406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan t = (-529, 576, -625, 676, -729) 38959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 389606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(t, shape=[5], format='@h') 38979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 389806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 38999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), nd.tobytes()) 39009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 390106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t], shape=[1], format='>hQiLl') 390206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 390306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 390406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 390506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 390606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t for _ in range(12)], shape=[2,2,3], format='=hQiLl') 390706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 390806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 390906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 391006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 391106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t for _ in range(120)], shape=[5,2,2,3,2], 391206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format='<hQiLl') 391306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 391406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 391506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 391606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 391706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Unknown formats are handled: tobytes() purely depends on itemsize. 391806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 391906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 392006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 392106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 392206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 392306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 392406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a.tobytes(), bytes(point)) 392506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 39269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_get_contiguous(self): 39279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 39289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # no buffer interface 39309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, {}, PyBUF_READ, 'F') 39319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to read-only object 39339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, b'x', PyBUF_WRITE, 'C') 39349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to non-contiguous object 39369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2]) 39379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'A') 39389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from read-only exporter 39409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L") 39419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from writable exporter 39479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 39489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, writable request 39549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9 39569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 10 39619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 10) 39629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[()], 10) 39639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 39659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 39669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 0) 39699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), []) 39719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 39739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 39749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), [[], []]) 39779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 39799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], format="h", flags=ND_WRITABLE) 39809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=ND_WRITABLE) 39869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional, non-contiguous 39929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 39939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 39989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 3) 39999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 3) 40009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-1] 40029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 40039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 40059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 40069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 40079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 1) 40089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 1) 40099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, contiguous input 40119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE) 40129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'A']: 40139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 40149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'F') 40179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], 40219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|ND_FORTRAN) 40229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['F', 'A']: 40239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 40249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'C') 40279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, non-contiguous input 40319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 40329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 40339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 40349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah order) 40359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags 40399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3,4,5], shape=[3], strides=[2]) 40409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, 'C') 40419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 40429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_serializing(self): 40449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 40469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('i') 40479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('i', [1,2,3,4,5]) 40489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 40499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 40509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(5*size) 40519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 40529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 40539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous, multi-dimensional 40559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('L') 40569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], format="L") 40579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 40599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(2*3*2*size) 40609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 40619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 40629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous, multi-dimensional 40649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #size = struct.calcsize('L') 40659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #nd = ndarray(list(range(12)), shape=[2,3,2], format="L", 40669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags=ND_FORTRAN) 40679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #m = memoryview(nd) 40689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf = io.BytesIO(m) 40699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #b = bytearray(2*3*2*size) 40709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf.readinto(b) 40719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #self.assertEqual(m.tobytes(), b) 40729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_hash(self): 40749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # bytes exporter 40769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 40779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 40789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(b), hash(m)) 40799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 40819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mc = m.cast('c', shape=[3,4]) 40829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mc), hash(b)) 40839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous 40859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mx = m[::-2] 40869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))[::-2]) 40879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mx), hash(b)) 40889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 40909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5], flags=ND_FORTRAN) 40919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(nd)) 40939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice 40959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5]) 40969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 40979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 40989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 40999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice with suboffsets 41019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[2,5,3], flags=ND_PIL) 41029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 41039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 41049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 41059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41064af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah # equality-hash invariant 41074af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah x = ndarray(list(range(12)), shape=[12], format='B') 4108b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah a = memoryview(x) 41094af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41104af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah y = ndarray(list(range(12)), shape=[12], format='b') 4111b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah b = memoryview(y) 41124af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 4113b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(a, b) 4114b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(hash(a), hash(b)) 41154af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 41179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 41189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 41194af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='h') 41229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 41234af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41244af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41254af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='= L') 41264af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 41274af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41284af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41294af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='< h') 41304af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 41314af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_release(self): 41349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create re-exporter from getbuffer(memoryview), then release the view. 41369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 41379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 41389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m) # re-exporter 41399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m.release) 41409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 41429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41434e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 41444e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(a) 41454e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41464e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41474e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m) 41484e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m.release) 41494e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 41504e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m.release() 41514e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # chained views 41539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 41549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 41559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m1) 41569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m2) # re-exporter 41579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 41589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m2.release) 41599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 41619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41624e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 41634e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1 = memoryview(a) 41644e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2 = memoryview(m1) 41654e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41664e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m2) 41684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1.release() 41694e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m2.release) 41704e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 41714e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2.release() 41724e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Allow changing layout while buffers are exported. 41749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 41759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 41769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([4,5,6,7,8], shape=[5]) # mutate nd 41789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 41799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = memoryview(m1) 41819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), m1.tolist()) 41829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = memoryview(m2) 41849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), m2.tolist()) 41859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), nd.tolist()) 41869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 41879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y.release() 41889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() # pop the current view 41909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), nd.tolist()) 41919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 41949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x.release() 41959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # If multiple memoryviews share the same managed buffer, implicit 41979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # release() in the context manager's __exit__() method should still 41989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # work. 41999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def catch22(b): 42009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(b) as m2: 42019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 42029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bytearray(b'123') 42049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(x) as m1: 42059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah catch22(m1) 42069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1[0], ord(b'1')) 42079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42084e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = ndarray(list(range(12)), shape=[2,2,3], format='l') 42094e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42104e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42114e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 42124e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m: 42134e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m) 42144e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[0:1].tolist(), [[[0, 1, 2], [3, 4, 5]]]) 42154e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42164e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah # Test garbage collection. 42174e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for flags in (0, ND_REDIRECT): 42184e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 42194e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 42204e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 42214e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 42224e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 42234e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 42244e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 42254e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 42264e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 42274e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 42284e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 42294e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 42304e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 42314e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 42324e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 42334e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m3 42344e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m2 42354e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1 42364e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42374e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 42384e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 42394e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 42404e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 42414e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 42424e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 42434e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 42444e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 42454e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 42464e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 42474e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 42484e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 42494e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 42504e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 42514e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 42524e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1, m2, m3 42534e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4254fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah # memoryview.release() fails if the view has exported buffers. 4255fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah x = bytearray(b'123') 4256fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with self.assertRaises(BufferError): 4257fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with memoryview(x) as m: 4258fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah ex = ndarray(m) 4259fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah m[0] == ord(b'1') 42609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42614e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah def test_memoryview_redirect(self): 42624e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42634e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd = ndarray([1.0 * x for x in range(12)], shape=[12], format='d') 42644e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = array.array('d', [1.0 * x for x in range(12)]) 42654e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42664e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for x in (nd, a): 42674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42694e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(z) 42704e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42714e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(y.obj, x) 42724e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 42734e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(m.obj, x) 42744e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42754e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, x) 42764e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, y) 42774e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, z) 42784e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42794e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 42804e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], y[1:3]) 42814e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], z[1:3]) 42824e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y, z 42834e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 42844e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4285bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah def test_memoryview_from_static_exporter(self): 4286bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4287bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah fmt = 'B' 4288bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst = [0,1,2,3,4,5,6,7,8,9,10,11] 4289bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4290bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # exceptions 4291bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertRaises(TypeError, staticarray, 1, 2, 3) 4292bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4293bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==x 4294bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4295bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4296bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=x, 4297bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4298bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4299bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4300bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4301bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4302bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4303bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4304bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4305bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4306bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4307bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4308bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4309bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4310bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4311bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4312bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4313bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4314bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4315bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4316bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4317bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4318bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4319bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4320bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4321bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4322bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4323bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4324bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4325bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4326bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4327bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, x) 4328bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, x) 4329bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=x, 4330bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4331bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4332bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4333bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4334bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4335bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==NULL 4336bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4337bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4338bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=None, 4339bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4340bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4341bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4342bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4343bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4344bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4345bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4346bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4347bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4348bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4349bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4350bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4351bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4352bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4353bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4354bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4355bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4356bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4357bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4358bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4359bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4360bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4361bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4362bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4363bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4364bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4365bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4366bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4367bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4368bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # Clearly setting view.obj==NULL is inferior, since it 4369bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # messes up the redirection chain: 4370bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4371bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, y) 4372bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, y) 4373bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=y, 4374bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4375bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4376bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4377bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4378bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 43791649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah def test_memoryview_getbuffer_undefined(self): 43801649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 43811649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah # getbufferproc does not adhere to the new documentation 43821649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah nd = ndarray([1,2,3], [3], flags=ND_GETBUF_FAIL|ND_GETBUF_UNDEFINED) 43831649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah self.assertRaises(BufferError, memoryview, nd) 43841649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 43859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_issue_7385(self): 43869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1,2,3], shape=[3], flags=ND_GETBUF_FAIL) 43879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, x) 43889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 43899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 43909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif __name__ == "__main__": 43913e9a9ae09d6fc9169b01cba3efd1ae03ab40b237Brett Cannon unittest.main() 4392