test_buffer.py revision 0ce5b6e2688ddf342780b663a095b3e0c9f5cc72
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 8440ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah # test hex() 8450ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah m = memoryview(result) 8460ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah h = "".join("%02x" % c for c in b) 8470ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah self.assertEqual(m.hex(), h) 8480ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah 8499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # lst := expected multi-dimensional logical representation 8509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flatten(lst) := elements in C-order 8519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ff = fmt if fmt else 'B' 8529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flattened = flatten(lst) 8539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Rules for 'A': if the array is already contiguous, return 8559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # the array unaltered. Otherwise, return a contiguous 'C' 8569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # representation. 8579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 8589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = result 8599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if order == 'F': 8609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'C'): 8629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # For constructing the ndarray, convert the 8639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flattened logical representation to Fortran order. 8649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah trans = transpose(flattened, shape) 8659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(trans, shape=shape, format=ff, 8669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 8679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: # 'C', 'A' 8689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'F') and order == 'C': 8709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The flattened list is already in C-order. 8719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(flattened, shape=shape, format=ff) 8727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah contig = get_contiguous(result, PyBUF_READ, order) 8749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(contig.tobytes(), b) 8759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(contig, expected)) 8769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if ndim == 0: 8787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 8797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nmemb = len(flattened) 8817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ro = 0 if readonly else ND_WRITABLE 8827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### See comment in test_py_buffer_to_contiguous for an 8847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### explanation why these tests are valid. 8857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'C' 8877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'C', PyBUF_FULL_RO) 8887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 88906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 8907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 89106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 89206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 8937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro, format=fmt) 8957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 8967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'F' 8987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'F', PyBUF_FULL_RO) 8997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 90006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 9017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 90206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 90306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 9047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro|ND_FORTRAN, 9067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah format=fmt) 9077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'A' 9107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'A', PyBUF_FULL_RO) 9117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 91206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 9137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 91406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 91506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 9167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah f = ND_FORTRAN if is_contiguous(result, 'F') else 0 9187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=f|ro, format=fmt) 9197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 9229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 9239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(result) 9249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except BufferError: # re-exporter does not provide full information 9259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = result.obj if isinstance(result, memoryview) else result 9279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m.obj, ex) 9289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.nbytes, expected_len) 9299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.itemsize, itemsize) 9309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.format, fmt) 9319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.readonly, readonly) 9329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.ndim, ndim) 9339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.shape, tuple(shape)) 9349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not (sliced and suboffsets): 9359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.strides, tuple(strides)) 9369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.suboffsets, tuple(suboffsets)) 9379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 1 if ndim == 0 else len(lst) 9399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), n) 9409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rep = result.tolist() if fmt else result.tobytes() 9429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(rep, lst) 9439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, result) 9449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def verify_getbuf(self, orig_ex, ex, req, sliced=False): 9469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def simple_fmt(ex): 9479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ex.format == '' or ex.format == 'B' 9489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def match(req, flag): 9499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ((req&flag) == flag) 9509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (# writable request to read-only exporter 9529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (ex.readonly and match(req, PyBUF_WRITABLE)) or 9539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot match explicit contiguity request 9549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_C_CONTIGUOUS) and not ex.c_contiguous) or 9559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_F_CONTIGUOUS) and not ex.f_contiguous) or 9569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_ANY_CONTIGUOUS) and not ex.contiguous) or 9579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer needs suboffsets 9589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_INDIRECT) and ex.suboffsets) or 9599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer without strides must be C-contiguous 9609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_STRIDES) and not ex.c_contiguous) or 9619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_SIMPLE|PyBUF_FORMAT and PyBUF_WRITABLE|PyBUF_FORMAT 9629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_ND) and match(req, PyBUF_FORMAT))): 9639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=req) 9659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(ex, ndarray) or is_memoryview_format(ex.format): 9689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 9699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 9709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_FULL_RO) 9719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 9729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The consumer may have requested default values or a NULL format. 9749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ro = 0 if match(req, PyBUF_WRITABLE) else ex.readonly 9759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = ex.format 9769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = ex.itemsize 9779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = ex.ndim 9789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_FORMAT): 9799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # itemsize refers to the original itemsize before the cast. 9809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality product(shape) * itemsize = len still holds. 9819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality calcsize(format) = itemsize does _not_ hold. 9829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = '' 9839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = orig_ex.tobytes() # Issue 12834 9849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_ND): 9859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = 1 9869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = orig_ex.shape if match(req, PyBUF_ND) else () 9879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = orig_ex.strides if match(req, PyBUF_STRIDES) else () 9889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=req) 9909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=ex, 9919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=ro, 9929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 9939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, sliced=sliced) 9949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_getbuf(self): 9969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah requests = ( 9979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # distinct flags 9989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 9999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_C_CONTIGUOUS, PyBUF_F_CONTIGUOUS, PyBUF_ANY_CONTIGUOUS, 10009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # compound requests 10019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_FULL, PyBUF_FULL_RO, 10029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 10039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 10049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 10059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # items and format 10079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_fmt = ( 10089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([True if x % 2 else False for x in range(12)], '?'), 10099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'b'), 10109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'B'), 10119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([(2**31-x) if x % 2 else (-2**31+x) for x in range(12)], 'l') 10129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # shape, strides, offset 10149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah structure = ( 10159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([], [], 0), 1016363af44a4abff02ece61e456d55824f298448992Stefan Krah ([1,3,1], [], 0), 10179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [], 0), 10189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [-1], 11), 10199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [2], 0), 10209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [-2], 11), 10219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [], 0), 10229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [-4, -1], 11), 10239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [4, 1], 4), 10249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [-4, -1], 8) 10259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray creation flags 10279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndflags = ( 10289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 0, ND_WRITABLE, ND_FORTRAN, ND_FORTRAN|ND_WRITABLE, 10299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ND_PIL, ND_PIL|ND_WRITABLE 10309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags that can actually be used as flags 10329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah real_flags = (0, PyBUF_WRITABLE, PyBUF_FORMAT, 10339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_WRITABLE|PyBUF_FORMAT) 10349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, fmt in items_fmt: 10369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 10379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape, strides, offset in structure: 10389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [v * itemsize for v in strides] 10399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset *= itemsize 10409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in ndflags: 10419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides and (flags&ND_FORTRAN): 10439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape and (flags&ND_PIL): 10459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _items = items if shape else items[0] 10489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(_items, format=fmt, flags=flags, 10499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape=shape, strides=strides, offset=offset) 10509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ex1[::-2] if shape else None 10519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 10539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 10559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex1.ndim == 0 or (ex1.ndim == 1 and shape and strides): 10569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 10579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2 and ex2.ndim == 1 and shape and strides: 10589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 10599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for req in requests: 10619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bits in real_flags: 10629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, ex1, req|bits) 10639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, m1, req|bits) 10649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, ex2, req|bits, 10669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, m2, req|bits, 10689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 10719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_GETBUF_FAIL 10739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[12], flags=ND_GETBUF_FAIL) 10749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex) 10759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Request complex structure from a simple exporter. In this 10779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # particular case the test object is not PEP-3118 compliant. 10789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah base = ndarray([9], [1]) 10799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(base, getbuf=PyBUF_SIMPLE) 10809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_WRITABLE) 10819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ND) 10829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_STRIDES) 10839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_C_CONTIGUOUS) 10849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_F_CONTIGUOUS) 10859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ANY_CONTIGUOUS) 10869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 10879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1088363af44a4abff02ece61e456d55824f298448992Stefan Krah # Issue #22445: New precise contiguity definition. 1089363af44a4abff02ece61e456d55824f298448992Stefan Krah for shape in [1,12,1], [7,0,7]: 1090363af44a4abff02ece61e456d55824f298448992Stefan Krah for order in 0, ND_FORTRAN: 1091363af44a4abff02ece61e456d55824f298448992Stefan Krah ex = ndarray(items, shape=shape, flags=order|ND_WRITABLE) 1092363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(ex, 'F')) 1093363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(ex, 'C')) 1094363af44a4abff02ece61e456d55824f298448992Stefan Krah 1095363af44a4abff02ece61e456d55824f298448992Stefan Krah for flags in requests: 1096363af44a4abff02ece61e456d55824f298448992Stefan Krah nd = ndarray(ex, getbuf=flags) 1097363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(nd, 'F')) 1098363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(nd, 'C')) 1099363af44a4abff02ece61e456d55824f298448992Stefan Krah 11009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_exceptions(self): 11019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 11029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndm = ndarray([9], [1], flags=ND_VAREXPORT) 11039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Initialization of a new ndarray or mutation of an existing array. 11059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for c in (ndarray, nd.push, ndm.push): 11069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid types. 11079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, {1,2,3}) 11089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,'3']) 11099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,(3,4)]) 11109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape={3}) 11119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], strides={1}) 11129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], offset=[]) 11139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], format={}) 11149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], flags={}) 11159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf={}) 11169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_FORTRAN flag is only valid without strides. 11189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], strides=[1], 11199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 11209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_PIL flag is only valid with ndim > 0. 11229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[], flags=ND_PIL) 11239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid items. 11259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [], shape=[1]) 11269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, ['XXX'], shape=[1], format="L") 11279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of items and format. 11289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [1000], shape=[1], format="B") 11299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,(2,3)], shape=[2], format="B") 11309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="QL") 11319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid ndim. 11339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM+1 11349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1]*n, shape=[1]*n) 11359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid shape. 11379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1], shape=[-1]) 11389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=['3']) 11399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[2**128]) 11409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # prod(shape) * itemsize != len(items) 11419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4,5], shape=[2,2], offset=3) 11429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid strides. 11449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], strides=['1']) 11459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[1], 11469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[2**128]) 11479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and shape. 11499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2], shape=[2,1], strides=[1]) 11509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and format. 11519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4], shape=[2], strides=[3], 11529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid offset. 11559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], offset=4) 11569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[1], offset=3, 11579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid format. 11609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="") 11619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [(1,2,3)], shape=[1], 11629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="@#$") 11639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Striding out of the memory bounds. 11659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10] 11669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, items, shape=[2,3], 11679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[-3, -2], offset=5) 11689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing consumer: format argument invalid. 11709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, bytearray(), format="Q") 11719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing original base object: getbuf argument invalid. 11739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf=PyBUF_FULL) 11749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Shape argument is mandatory for original base objects. 11769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1]) 11779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_WRITABLE request to read-only provider. 11809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, b'123', getbuf=PyBUF_WRITABLE) 11819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT can only be specified during construction. 11839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1], flags=ND_VAREXPORT) 11849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.push, [1], [1], flags=ND_VAREXPORT) 11859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid operation for consumers: push/pop 11879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(b'123') 11889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT not set: push/pop fail with exported buffers 11929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 11939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1], [1]) 11949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 11959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 11989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() 11999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Single remaining buffer: pop fails 12019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 12029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 12039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_pointer() 12059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, {}, [1,2,3]) 12069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, b'123', {}) 12079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(100)), shape=[1]*100) 12099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [5]) 12109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 12129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [2,3,4]) 12139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [3,3]) 12149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [-3,3]) 12159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_pointer, nd, [1<<64,3]) 12169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # tolist() needs format 12189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format='L') 12199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 12209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.tolist) 12219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview_from_buffer() 12239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray([1,2,3], shape=[3], format='L') 12249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(ex1) 12259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex2) 12269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([(1,)*200], shape=[1], format='L'*200) 12299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM 12329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(n)), shape=[1]*n) 12339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 12349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_contiguous() 12369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, 1, 2, 3, 4, 5) 12389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, "xyz", 'C') 12399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_contiguous, nd, 2**64, 'C') 12409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, PyBUF_READ, 961) 12419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(UnicodeEncodeError, get_contiguous, nd, PyBUF_READ, 12429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '\u2007') 124366e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'Z') 124466e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, 255, 'A') 12459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cmp_contig() 12479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, 1, 2, 3, 4, 5) 12499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, {}, nd) 12509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, nd, {}) 12519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is_contiguous() 12539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, 1, 2, 3, 4, 5) 12559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, {}, 'A') 12569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, nd, 201) 12579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_linked_list(self): 12599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for perm in permutations(range(5)): 12609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = [0]*5 12619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 12629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = memoryview(nd) 12639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(1, 5): 12659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1,2,3], shape=[3]) 12669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = memoryview(nd) 12679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 12699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[perm[i]].release() 12709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 12729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 12739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_scalar(self): 12759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0: scalar 12769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, scalar, _ in iter_format(0): 12779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(scalar, shape=(), format=fmt) 12799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 12829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=scalar) 12839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_shape(self): 12859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, shape = [n] 12869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 10) 12879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 12889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 12909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[nitems], format=fmt, flags=flags) 12919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=(nitems,), strides=(itemsize,), 12949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items) 12959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_strides(self): 12979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, strides 12989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 30) 12999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 13009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 13019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for step in range(-5, 5): 13029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if step == 0: 13039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 13049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [len(items[::step])] 13069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [step*itemsize] 13079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = itemsize*(nitems-1) if step < 0 else 0 13089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 13109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, strides=strides, 13119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format=fmt, offset=offset, flags=flags) 13129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=shape, strides=strides, 13159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items[::step]) 13169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_fortran(self): 13189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 13199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=(3, 4), strides=(1, 3)) 13209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_F_CONTIGUOUS|PyBUF_FORMAT) 13219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), farray(items, (3, 4))) 13229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_multidim(self): 13249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ndim in range(5): 13259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = [randrange(2, 10) for _ in range(ndim)] 13269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 13279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 13289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 13309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 13319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 13339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim == 0 and flags == ND_PIL: 13349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 13359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 13379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 13389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'C') 13409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 13419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 13479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: reconstruct strides 13489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 13499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 13509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nd.strides == ()) 13519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 13529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=None, 13539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 13589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 13599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 13609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'F') 13629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 13639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_invalid(self): 13699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # not writable 13709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 13719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 1, 8) 13729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, 8) 13759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot be deleted 13779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__delitem__, 1) 13799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__delitem__, 1) 13829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # overflow 13849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__getitem__, 1<<64) 13869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__setitem__, 1<<64, 8) 13879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 1<<64) 13909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 1<<64, 8) 13919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format 13939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 13949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="B", flags=ND_WRITABLE) 13959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 2, 300) 13969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 1, (100, 200)) 13979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__setitem__, 2, 300) 14009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, (100, 200)) 14019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [(1,2), (3,4), (5,6)] 14039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="LQ", flags=ND_WRITABLE) 14049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 2, 300) 14059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 1, (b'\x001', 200)) 14069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_scalar(self): 14089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar 14099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=(), flags=ND_WRITABLE) 14109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[()]; self.assertEqual(x, 1) 14149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[...]; self.assertEqual(x.tolist(), nd.tolist()) 14159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[()]; self.assertEqual(x, 1) 14179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[...]; self.assertEqual(x.tolist(), nd.tolist()) 14189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, 0) 14209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, 0) 14219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 0, 8) 14229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 0, 8) 14239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 1) 14259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), 1) 14269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9; self.assertEqual(nd.tolist(), 9) 14289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[()] = 9; self.assertEqual(mv.tolist(), 9) 14299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[...] = 5; self.assertEqual(nd.tolist(), 5) 14319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[...] = 5; self.assertEqual(mv.tolist(), 5) 14329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_null_strides(self): 14349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*4)), shape=[2, 4], flags=ND_WRITABLE) 14359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG) 14369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Sub-views are only possible for full exporters. 14389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, 1) 14399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Same for slices. 14409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, slice(3,5,1)) 14419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_single(self): 14439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem 14449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 14469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, -6) 14509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, 5) 14519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, -6) 14599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 5) 14609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null strides 14629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], flags=ND_WRITABLE, format=fmt) 14649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG|PyBUF_FORMAT) 14659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 14719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mv.__eq__(nd), NotImplemented) 14729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null format 14769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO) 14799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null shape/strides/format 14839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 14869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_setitem_single(self): 14919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value 14929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 14939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 14949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 14959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 14969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = single_item 14979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 14989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, -6, single_item) 15009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, 5, single_item) 15019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 15039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 15049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 15099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 15109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = single_item 15119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 15129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, -6, single_item) 15149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 5, single_item) 15159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value: lobject = robject 15189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 15199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = nd[i+1] 15239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 15249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 15269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 15279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = mv[i+1] 15349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 15359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_multidim(self): 15379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 15389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 15399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 15409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 15429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 15449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 15459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 15469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 15479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(-shape[2], shape[2]): 15539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 15569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 15579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 15589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 15599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(shape[2], shape[2]): 15659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_sequence(self): 15689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=()) 15699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in nd", locals()) 15709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in mv", locals()) 15739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 15759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 15769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(nd): 15779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in nd) 15799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 15819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(mv): 15839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in mv) 15859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_invalid(self): 15879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 15889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 15909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 15929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, xl.__setitem__, slice(0,8,1), items) 15939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, ml.__setitem__, slice(0,8,1), items) 15949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not a full exporter 15969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], flags=ND_WRITABLE) 15989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(ex, getbuf=PyBUF_ND) 15999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, xl.__setitem__, slice(0,8,1), xr) 16009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 16029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[8], format="L", flags=ND_WRITABLE) 16039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 16049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, slice(0,1,0)) 16059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__getitem__, slice(0,1,0)) 16069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[2,4], format="L", flags=ND_WRITABLE) 16089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 16099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 16119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 16129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 16139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,0), slice(0,1,1))) 16149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, "@%$") 16159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, ("@%$", slice(0,1,1))) 16169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, (slice(0,1,1), {})) 16179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: not implemented 16199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, mv.__getitem__, 16209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 16219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, "@%$") 16229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing format 16249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing itemsize 16349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray(items, shape=[8], format="L") 16369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing ndim 16449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[2, 4], format="b", flags=ND_WRITABLE) 16459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), [[1,2,3,4], [5,6,7,8]]) 16509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, ml.__setitem__, slice(0,1,1), 16519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr[7:8]) 16529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing shape 16549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="b", flags=ND_WRITABLE) 16559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,2,1), xr[7:8]) 16599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,2,1), mr[7:8]) 16619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # _testbuffer.c module functions 16649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, slice(0,1,2), {}) 16659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, "###########", 1) 16669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, slice_indices, slice(0,1,0), 4) 16679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[8], format="b", flags=ND_PIL) 16699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], format="B") 16729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(ex, getbuf=PyBUF_SIMPLE) 16739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_zero_shape(self): 16769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 16779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[12], format="L", flags=ND_WRITABLE) 16799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[12], format="L") 16809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[4:4] = y[9:9] 16819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), items) 16829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(x) 16849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(y) 16859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, x) 16869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, y) 16879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml[4:4] = mr[9:9] 16889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[3, 4], format="L", flags=ND_WRITABLE) 16919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[4, 3], format="L") 16929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[1:2, 2:2] = y[1:2, 3:3] 16939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), carray(items, [3, 4])) 16949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_multidim(self): 16969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 16979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 16989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 16999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 17009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 17029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 17039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 17059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 17069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 17079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 17099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 17119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 17139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 17159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_redundant_suboffsets(self): 17289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5, 2) 17299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 17309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 17319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 17329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 17349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 17359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt) 17379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.add_suboffsets() 17389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 17399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex.add_suboffsets() 17409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 17429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 17449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 17469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 17489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 17509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_single(self): 17639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 17649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(5): 17659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(5): 17669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 17679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f = flags|ND_WRITABLE 17699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=f) 17709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], format=fmt, flags=f) 17719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = None 17749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = None 17759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = items[:] 17769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lval = lst[lslice] 17789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rval = lst[rslice] 17799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[lslice] = lst[rslice] 17809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = len(lval) != len(rval) 17819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = e.__class__ 17839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslice] = nd[rslice] 17879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # ndarray cannot change shape 17919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, ValueError) 17929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), lst) 17949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, lsterr) 17959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 17979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 17989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = None 18009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[lslice] = mv[rslice] 18029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = e.__class__ 18049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # memoryview cannot change shape 18069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, ValueError) 18079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 18089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), lst) 18099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 18109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, lsterr) 18119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=ex, 18129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=nd.itemsize, fmt=fmt, readonly=0, 18139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=nd.ndim, shape=nd.shape, strides=nd.strides, 18149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=nd.tolist()) 18159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_multidim(self): 18179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 18189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 18199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 18209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 18219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 18239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 18259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices, rslices = randslice_from_shape(ndim, shape) 18279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 18299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_WRITABLE) 18309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 18319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 18339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah result = multislice_assign(lst, lst, lslices, rslices) 18359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 18379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 18399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslices] = nd[rslices] 18419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 18439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 18459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 18469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 18479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), result) 18489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random(self): 18509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # construction of valid arrays 18519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, True, maxdim=MAXDIM, 18569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*t)) 18589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 18599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 18619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xlist = x.tolist() 18629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(x) 18649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, xlist) 18679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if t[2] > 0: 18699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 18709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray_from_structure(items, fmt, t, flags=ND_PIL) 18719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ylist = y.tolist() 18729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xlist, ylist) 18739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(y) 18759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, y) 18779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, ylist) 18799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 18819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = t[3] 18829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in shape: 18839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 18849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah z = numpy_array_from_structure(items, fmt, t) 18859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(x, obj=None, 18869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=z.itemsize, fmt=fmt, readonly=0, 18879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=z.ndim, shape=z.shape, strides=z.strides, 18889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=z.tolist()) 18899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_invalid(self): 18919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # exceptions during construction of invalid arrays 18929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, False, maxdim=MAXDIM, 18979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(verify_structure(*t)) 18999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 19009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = False 19029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 19039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 19049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 19059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 19069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nderr) 19079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 19099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = False 19109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 19119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = numpy_array_from_structure(items, fmt, t) 19129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 19139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = e.__class__ 19149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0: # http://projects.scipy.org/numpy/ticket/1910 19169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(numpy_err) 19179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_slice_assign(self): 19199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # valid slice assignments 19209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 19219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 19229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 19239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape, rshape, lslices, rslices = \ 19259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rand_aligned_slices(maxdim=MAXDIM, maxshape=MAXSHAPE) 19269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tl = rand_structure(itemsize, True, shape=lshape) 19279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tr = rand_structure(itemsize, True, shape=rshape) 19289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tl)) 19299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tr)) 19309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah litems = randitems_from_structure(fmt, tl) 19319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ritems = randitems_from_structure(fmt, tr) 19329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray_from_structure(litems, fmt, tl) 19349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray_from_structure(ritems, fmt, tr) 19359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl[lslices] = xr[rslices] 19369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xllist = xl.tolist() 19379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xrlist = xr.tolist() 19389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 19409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 19419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), xllist) 19429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), xrlist) 19439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if tl[2] > 0 and tr[2] > 0: 19459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 19469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl = ndarray_from_structure(litems, fmt, tl, flags=ND_PIL) 19479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray_from_structure(ritems, fmt, tr, flags=ND_PIL) 19489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl[lslices] = yr[rslices] 19499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yllist = yl.tolist() 19509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yrlist = yr.tolist() 19519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xllist, yllist) 19529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xrlist, yrlist) 19539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(yl) 19559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(yr) 19569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), yllist) 19579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), yrlist) 19589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 19609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in lshape or 0 in rshape: 19619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 19629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl = numpy_array_from_structure(litems, fmt, tl) 19649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zr = numpy_array_from_structure(ritems, fmt, tr) 19659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl[lslices] = zr[rslices] 19669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_overlapping(tl) and not is_overlapping(tr): 19689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Slice assignment of overlapping structures 19699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is undefined in NumPy. 19709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xl, obj=None, 19719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zl.itemsize, fmt=fmt, readonly=0, 19729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zl.ndim, shape=zl.shape, 19739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zl.strides, lst=zl.tolist()) 19749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xr, obj=None, 19769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zr.itemsize, fmt=fmt, readonly=0, 19779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zr.ndim, shape=zr.shape, 19789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zr.strides, lst=zr.tolist()) 19799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_re_export(self): 19819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 19829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[3,4], flags=ND_PIL) 19849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(nd) 19859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.flags & ND_PIL) 19879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(ex.obj, nd) 19889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ex.suboffsets, (0, -1)) 19899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 19909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.f_contiguous) 19919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.contiguous) 19929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_shape(self): 19949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 19959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 19969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0], flags=flags) 19979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 19989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 19999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 20009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), []) 20019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0,3,3], flags=flags) 20039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 20049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,0,3], flags=flags) 20069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [[], [], []]) 20079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,3,0], flags=flags) 20099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 20109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [[[], [], []], [[], [], []], [[], [], []]]) 20119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_strides(self): 20139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero strides 20149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[5], strides=[0], flags=flags) 20169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 20179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 20189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [1, 1, 1, 1, 1]) 20199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), [1, 1, 1, 1, 1]) 20209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_offset(self): 20229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(20)), shape=[3], offset=7) 20239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.offset, 7) 20249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [7,8,9]) 20259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_memoryview_from_buffer(self): 20279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 20309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 20319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_get_pointer(self): 20339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(3): 20369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], get_pointer(nd, [i])) 20379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_tolist_null_strides(self): 20399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(20)), shape=[2,2,5]) 20409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_ND|PyBUF_FORMAT) 20429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), ex.tolist()) 20439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 20459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 20469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_cmp_contig(self): 20489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(b"123", b"456")) 20509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(list(range(12)), shape=[3,4]) 20529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(list(range(12)), shape=[4,3]) 20539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(x, y)) 20549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1], shape=[1], format="B") 20569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(x, b'\x01')) 20579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(b'\x01', x)) 20589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_hash(self): 20609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1,2,3]) 20629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(a) 20639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, hash, nd) 20649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 20669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12]) 20699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 20729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 20739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,2,2]) 20769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 20799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[4,3])) 20809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4], flags=ND_FORTRAN) 20819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[2,3,2])) 20849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], flags=ND_FORTRAN) 20859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # suboffsets 20889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], flags=ND_PIL) 20909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 20939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 20949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(nd.tobytes())) 20959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah def test_py_buffer_to_contiguous(self): 20977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 20987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # The requests are used in _testbuffer.c:py_buffer_to_contiguous 20997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # to generate buffers without full information for testing. 21007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah requests = ( 21017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # distinct flags 21027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 21037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # compound requests 21047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL, PyBUF_FULL_RO, 21057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 21067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 21077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 21087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ) 21097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # no buffer interface 21117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertRaises(TypeError, py_buffer_to_contiguous, {}, 'F', 21127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL_RO) 21137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # scalar, read-only request 21157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 21167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 21207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # zeros in shape 21227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 21237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 21297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 21307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### One-dimensional arrays are trivial, since Fortran and C order 21367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### are the same. 21377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional 21397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 21407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[1], format="h", flags=f|ND_WRITABLE) 21417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=f|ND_WRITABLE) 21487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional, non-contiguous input 21557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 21567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_STRIDES, PyBUF_FULL]: 21597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = nd[::-1] 21637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 21677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 21697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 21707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Multi-dimensional arrays: 21747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The goal here is to preserve the logical representation of the 21767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### input array but change the physical representation if necessary. 21777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer example: 21797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ==================== 21807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input array: 21827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------------- 21837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(list(range(12)), shape=[3, 4]) 21847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 21867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 21877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 21887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 21907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 21917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 21927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 21937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The return value corresponds to this input list for 21957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray: 21967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray([0,4,8,1,5,9,2,6,10,3,7,11], shape=[3,4], 21977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### flags=ND_FORTRAN) 21987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 22007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 22017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 22027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The logical array is the same, but the values in memory are now 22047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### in Fortran order. 22057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### NumPy example: 22077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ============== 22087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray takes lists to initialize the memory. 22097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Here's the same sequence in NumPy: 22107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input: 22127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------- 22137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=bytearray(list(range(12))), 22147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### shape=[3, 4], dtype='B') 22157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 22167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 22177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 22187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 22217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 22227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf = nd.tostring(order='F') 22237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf 22247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 22257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=fortran_buf, shape=[3, 4], 22277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### dtype='B', order='F') 22287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 22307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 22317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 22327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, contiguous input 22367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah lst = list(range(12)) 22377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 22387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(lst, shape=[3, 4], flags=f|ND_WRITABLE) 22397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah na = numpy_array(buffer=bytearray(lst), 22417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah shape=[3, 4], dtype='B', 22427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah order='C' if f == 0 else 'F') 22437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' request 22457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: # 'F' to 'C' 22467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [4, 3]), shape=[3, 4], 22477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 22527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', request) 22547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a C array that is logically identical to the input array. 22617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 22627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='C')) 22667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' request 22687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == 0: # 'C' to 'F' 22697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], 22707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', request) 22787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a Fortran array that is logically identical to the input array. 22847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 22857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='F')) 22897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' request 22917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: 22927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', request) 23007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 23017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 23027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 23047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 23067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # an array with order=f that is logically identical to the input 23077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # array. 23087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=f|ND_WRITABLE) 23097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 23127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='A')) 23137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, non-contiguous input 23157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 23167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' 23187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', PyBUF_FULL_RO) 23197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' 23247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 23257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], flags=ND_WRITABLE) 23267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, x.tobytes()) 23277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 23287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' 23317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', PyBUF_FULL_RO) 23327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_construction(self): 23379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_shape = [(9, []), ([1,2,3], [3]), (list(range(2*3*5)), [2,3,5])] 23399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, C-contiguous: 23419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 23459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 23479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'C') 23519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 23529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 23549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 23599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 23609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 23619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no strides 23669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 23679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no format, shape, strides 23759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 23769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.format, '') 23779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.shape, ()) 23789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [items] if ndim == 0 else items 23829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[ex.nbytes], strides=(1,), 23859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, Fortran contiguous: 23889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_FORTRAN) 23929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.f_contiguous) 23949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'F') 23989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 23999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 24019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 24039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 24069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 24079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 24089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 24109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PIL style: 24139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape[1:]: 24149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 24169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_PIL) 24179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 24189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 24209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 24219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 24239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 24289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 24299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 24309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid number of arguments: 24359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, b'9', 'x') 24369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not a buffer provider: 24379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, {}) 24389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Non-compliant buffer provider: 24399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3]) 24409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 24419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 24439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 64 24469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1]*128, shape=[1]*128, format='L') 24479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, nd) 24489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 24499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'C') 24509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'F') 24519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd[::-1], PyBUF_READ, 'C') 24529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_shape(self): 245460b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Casts are undefined if buffer is multidimensional and shape 245560b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # contains zeros. These arrays are regarded as C-contiguous by 245660b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Numpy and PyBuffer_GetContiguous(), so they are not caught by 245760b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # the test for C-contiguity in memory_cast(). 24589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3] 24599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in ([0,3,3], [3,0,3], [0,3,3]): 24609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 24619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.c_contiguous) 24629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 24639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 246460b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Monodimensional empty view can be cast (issue #19014). 246560b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou for fmt, _, _ in iter_format(1, 'memoryview'): 246660b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou msrc = memoryview(b'') 246760b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou m = msrc.cast(fmt) 246860b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou self.assertEqual(m.tobytes(), b'') 246960b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou self.assertEqual(m.tolist(), []) 24709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2471a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check_sizeof = support.check_sizeof 2472a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 2473a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou def test_memoryview_sizeof(self): 2474a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check = self.check_sizeof 2475a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou vsize = support.calcvobjsize 247663afdaa1105de24e87658e82de314a37d341f02bAntoine Pitrou base_struct = 'Pnin 2P2n2i5P P' 2477a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou per_dim = '3n' 2478a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 2479a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou items = list(range(8)) 2480a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(b''), vsize(base_struct + 1 * per_dim)) 2481a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou a = ndarray(items, shape=[2, 4], format="b") 2482a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(a), vsize(base_struct + 2 * per_dim)) 2483a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou a = ndarray(items, shape=[2, 2, 2], format="b") 2484a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(a), vsize(base_struct + 3 * per_dim)) 2485a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 24869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_struct_module(self): 24879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class INT(object): 24899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __int__(self): 24929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class IDX(object): 24959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __index__(self): 24989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def f(): return 7 25019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah values = [INT(9), IDX(9), 25039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2.2+3j, Decimal("-21.1"), 12.2, Fraction(5, 2), 25049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1,2,3], {4,5,6}, {7:8}, (), (9,), 25059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah True, False, None, NotImplemented, 25069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b'a', b'abc', bytearray(b'a'), bytearray(b'abc'), 25079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'a', 'abc', r'a', r'abc', 25089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f, lambda x: x] 25099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, item in iter_format(10, 'memoryview'): 25119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 25129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 25139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, 0, item) 25169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = item 25179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[0], nd[0]) 25189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 25209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 'P' in fmt: 25219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 25229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in values: 25249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = None 25259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 25269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, itemsize, v) 25279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 25289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = struct.error 25299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = None 25319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 25329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = v 25339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except (TypeError, ValueError) as e: 25349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = e.__class__ 25359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if struct_err or mv_err: 25379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(struct_err, None) 25389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(mv_err, None) 25399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 25409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], nd[1]) 25419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_strides(self): 25439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Casts are undefined if strides contains zeros. These arrays are 25449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # (sometimes!) regarded as C-contiguous by Numpy, but not by 25459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBuffer_GetContiguous(). 25469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], strides=[0]) 25479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 25489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 25509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_invalid(self): 25529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid format 25539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt in NON_BYTE_FORMAT: 25549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sformat = '@' + sfmt if randrange(2) else sfmt 25559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ssize = struct.calcsize(sformat) 25569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt in NON_BYTE_FORMAT: 25579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dformat = '@' + dfmt if randrange(2) else dfmt 25589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dsize = struct.calcsize(dformat) 25599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(32)), shape=[32//ssize], format=sformat) 25609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, [32//dsize]) 25629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt, sitems, _ in iter_format(1): 25649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(sitems, shape=[1], format=sfmt) 25659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt, _, _ in iter_format(1): 25670c51595a784787d8e198af910cb6d79172ee52bbStefan Krah if not is_memoryview_format(dfmt): 25689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, msrc.cast, dfmt, 25699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 25719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_byte_format(sfmt) and not is_byte_format(dfmt): 25729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, 25739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid shape 25769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_h = struct.calcsize('h') 25779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_d = struct.calcsize('d') 25789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*2*size_d)), shape=[2,2,size_d], format='h') 25799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, shape=[2,2,size_h], format='d') 25819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 25839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect number of args 25869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast) 25879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, 1, 2, 3) 25889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format type 25909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, {}) 25919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format 25939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "X") 25949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@X") 25959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@XY") 25969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # dest format not implemented 25989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "=B") 25999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "!L") 26009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "<P") 26019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, ">l") 26029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "BI") 26039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "xBI") 26049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # src format not implemented 26069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(1,2), (3,4)], shape=[2], format="II") 26079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 26099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 8) 26109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 26119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape type 26139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 26149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape={}) 26169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape elements 26189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[2*3*4*5]) 26199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, m.cast, "B", shape=[2**64]) 26219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[-1]) 26229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,-1]) 26239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,0]) 26249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5,6,7,'x']) 26259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # N-D -> N-D cast 26279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3,5,7,11]) 26289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5]) 26309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast with ndim > 64 26329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 26339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 26349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'I', [1]*128) 26359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # view->len not a multiple of itemsize 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, "I", shape=[2,3,4,5]) 26409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize != buffer size 26429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3*5*7*11]) 26439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5]) 26459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize overflow 26479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 26489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 26499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='B') 26509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 26519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if sys.maxsize == 2**63-1: 26529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [7, 7, 73, 127, 337, 92737, 649657]) 26549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**3]) 26569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**1]) 26589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 26599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1, 2147483647]) 26619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**5, 2**1]) 26639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**3, 2**1]) 26659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast(self): 26679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytespec = ( 26689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('B', lambda ex: list(ex.tobytes())), 26699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('b', lambda ex: [x-256 if x > 127 else x for x in list(ex.tobytes())]), 26709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('c', lambda ex: [bytes(chr(x), 'latin-1') for x in list(ex.tobytes())]), 26719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 26729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def iter_roundtrip(ex, m, items, fmt): 26749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize(fmt) 26759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bytefmt, to_bytelist in bytespec: 26769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(bytefmt) 26789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = to_bytelist(ex) 26799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt=bytefmt, readonly=0, 26819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31*srcsize], strides=(1,), 26829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 26859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m3, ex) 26869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 26879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, obj=ex, 26889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=srcsize, fmt=fmt, readonly=0, 26899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31], strides=(srcsize,), 26909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 0 to ndim = 1 26939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize('I') 26949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9, shape=[], format='I') 26959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'B', 1) 26969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('B') 26989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 27009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=destshape, strides=(1,), 27019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 27029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 1 to ndim = 0 27049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destsize = struct.calcsize('I') 27059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([9]*destsize, shape=[destsize], format='B') 27069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'I', destsize, shape=[]) 27079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('I', shape=[]) 27099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 27109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=destsize, fmt='I', readonly=1, 27119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 27129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 27139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # array.array: roundtrip to/from bytes 27159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'array'): 27169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, items) 27179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 27199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray: roundtrip to/from bytes 27219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'memoryview'): 27229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[31], format=fmt, flags=ND_WRITABLE) 27239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 27259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_1D_ND(self): 27279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Cast between C-contiguous buffers. At least one buffer must 27289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # be 1D, at least one format must be 'c', 'b' or 'B'. 27299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _tshape in gencastshapes(): 27309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@']: 27319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tfmt = ('', '@')[randrange(2)] + char 27329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tsize = struct.calcsize(tfmt) 27339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = prod(_tshape) * tsize 27349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah obj = 'memoryview' if is_byte_format(tfmt) else 'bytefmt' 27359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(n, obj): 27369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize(fmt) 27379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [n] if n > 0 else [] 27389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tshape = _tshape + [size] 27399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 27419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah titems, tshape = cast_items(ex, tfmt, tsize, shape=tshape) 27449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems is None: 27469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, tfmt, tshape) 27479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 27489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems == 'nan': 27499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # NaNs in lists are a recipe for trouble. 27509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # 1D -> ND 27529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(titems, shape=tshape, format=tfmt) 27539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(tfmt, shape=tshape) 27559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(tshape) 27569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = nd.strides 27579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 27589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 27599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=tsize, fmt=tfmt, readonly=1, 27609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=tshape, strides=strides, 27619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND -> 1D 27649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 27659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m4 = m2.cast(fmt, shape=shape) 27669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 27679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = ex.strides 27689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 27699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, 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 27759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m4, obj=ex, 27769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=size, fmt=fmt, readonly=1, 27779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 27789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27800c51595a784787d8e198af910cb6d79172ee52bbStefan Krah if ctypes: 27810c51595a784787d8e198af910cb6d79172ee52bbStefan Krah # format: "T{>l:x:>d:y:}" 27820c51595a784787d8e198af910cb6d79172ee52bbStefan Krah class BEPoint(ctypes.BigEndianStructure): 27830c51595a784787d8e198af910cb6d79172ee52bbStefan Krah _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_double)] 27840c51595a784787d8e198af910cb6d79172ee52bbStefan Krah point = BEPoint(100, 200.1) 27850c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m1 = memoryview(point) 27860c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m2 = m1.cast('B') 27870c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.obj, point) 27880c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.itemsize, 1) 27890c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.readonly, 0) 27900c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.ndim, 1) 27910c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.shape, (m2.nbytes,)) 27920c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.strides, (1,)) 27930c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.suboffsets, ()) 27940c51595a784787d8e198af910cb6d79172ee52bbStefan Krah 27950c51595a784787d8e198af910cb6d79172ee52bbStefan Krah x = ctypes.c_double(1.2) 27960c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m1 = memoryview(x) 27970c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m2 = m1.cast('c') 27980c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.obj, x) 27990c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.itemsize, 1) 28000c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.readonly, 0) 28010c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.ndim, 1) 28020c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.shape, (m2.nbytes,)) 28030c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.strides, (1,)) 28040c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.suboffsets, ()) 28050c51595a784787d8e198af910cb6d79172ee52bbStefan Krah 28069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tolist(self): 28079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Most tolist() tests are in self.verify() etc. 28099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('h', list(range(-6, 6))) 28119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 28129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 28139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 28149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = a[2::3] 28169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = m[2::3] 28179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 28189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 28199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*3*5*7*11)), shape=[11,2,7,3,5], format='L') 28219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 28239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(2, 5), (7, 11)], shape=[2], format='lh') 28259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s") 28299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b"a",b"b",b"c",b"d",b"e",b"f"], shape=[2,3], format='s') 28339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_repr(self): 28379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(bytearray(9)) 28389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 28399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<memory")) 28409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 28429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 28439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<released")) 28449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_sequence(self): 28469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in ('d', 'f'): 28489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah inf = float(3e400) 28499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, [1.0, inf, 3.0]) 28509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(1.0, m) 28529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(5e700, m) 28539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(3.0, m) 28549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9.0, [], format='f') 28569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "9.0 in m", locals()) 28589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 285931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou @contextlib.contextmanager 286031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou def assert_out_of_bounds_error(self, dim): 286131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assertRaises(IndexError) as cm: 286231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou yield 286331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(str(cm.exception), 286431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou "index out of bounds on dimension %d" % (dim,)) 286531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 28669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_index(self): 28679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 28699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='d') 28709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 12.5) 28729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], m) 28739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], ex) 28749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0) 28759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray((1,2,3), shape=[], format='iii') 28779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, ()) 28799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 28819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 28829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 2**64) 28859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 2.0) 28869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0.0) 28879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 28899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, -8) 28909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 8) 28919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 289231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # multi-dimensional 28939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 28949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 289631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[0, 0], 0) 289731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[2, 0], 8) 289831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[2, 3], 11) 289931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[-1, -1], 11) 290031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[-3, -4], 0) 290131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 290231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # out of bounds 290331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (3, -4): 290431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=1): 290531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[index, 0] 290631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (4, -5): 290731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=2): 290831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0, index] 290931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__getitem__, (2**64, 0)) 291031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__getitem__, (0, 2**64)) 291131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 291231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__getitem__, (0, 0, 0)) 291331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__getitem__, (0.0, 0.0)) 291431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 291531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # Not implemented: multidimensional sub-views 291631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(NotImplementedError, m.__getitem__, ()) 29179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 29189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_assign(self): 29209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 29229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='f', flags=ND_WRITABLE) 29239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 22.5 29259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 22.5) 29269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[...] = 23.5 29279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 23.5) 29289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 24.7) 29299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # read-only 29319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7]) 29329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2, 10) 29349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 29369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 29379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 2**64, 9) 29409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2.0, 10) 29419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0.0, 11) 29429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 29449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, -8, 20) 29459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 8, 25) 29469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() success: 29489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 29499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c' or fmt == '?': 29509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format=fmt, flags=ND_WRITABLE) 29529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah i = randrange(-3, 3) 29549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = 8 29559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], 8) 29569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], ex[i]) 29579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'1', b'2', b'3'], shape=[3], format='c', 29599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 29609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[2] = b'9' 29629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[2], b'9') 29639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([True, False, True], shape=[3], format='?', 29659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 29669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = True 29689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], True) 29699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() exceptions: 29719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([b'x'], shape=[1], format='c', flags=ND_WRITABLE) 29729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 29739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 100) 29749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5], flags=ND_WRITABLE) 29769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex) 29779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, _range in fmtdict['@'].items(): 29799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (fmt == '?'): # PyObject_IsTrue() accepts anything 29809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c': # special case tested above 29829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast(fmt) 29849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = _range 29859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'd' or fmt == 'f': 29869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = -2**1024, 2**1024 29879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt != 'P': # PyLong_AsVoidPtr() accepts negative numbers 29889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, lo-1) 29899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m2.__setitem__, 0, "xyz") 29909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, hi) 29919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid item 29939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast('c') 29949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, b'\xff\xff') 29959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format not implemented 29979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(1)), shape=[1], format="xL", flags=ND_WRITABLE) 29989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 30009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s", flags=ND_WRITABLE) 30029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 30049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 300531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # multi-dimensional 30069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 30079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 300831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0,1] = 42 300931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(ex[0][1], 42) 301031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[-1,-1] = 43 301131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(ex[2][3], 43) 301231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # errors 301331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (3, -4): 301431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=1): 301531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[index, 0] = 0 301631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (4, -5): 301731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=2): 301831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0, index] = 0 301931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__setitem__, (2**64, 0), 0) 302031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__setitem__, (0, 2**64), 0) 302131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 302231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__setitem__, (0, 0, 0), 0) 302331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__setitem__, (0.0, 0.0), 0) 30249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 302531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # Not implemented: multidimensional sub-views 30269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, [2, 3]) 30279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_slice(self): 30299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 30319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 30349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, slice(0,2,0)) 30359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, slice(0,2,0), 30369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 30379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 303831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # 0-dim slicing (identity function) 303931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(NotImplementedError, m.__getitem__, ()) 30409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multidimensional slices 30429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 30439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 30469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1))) 30479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 30489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1)), bytearray([1,2])) 30499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slice tuple 30519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, (slice(0,2,1), {})) 30529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, (slice(0,2,1), {}), 30539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 30549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 30569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, slice(0,1,1), [1]) 30579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous slice assignment 30599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 30609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(12)), shape=[12], strides=[-1], offset=11, 30619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|flags) 30629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(24)), shape=[12], strides=[2], flags=flags) 30639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 30649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 30659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[2:5] = ex1[2:5] 30679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[2:5] = m2[2:5] 30689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[1:3][::-1] = ex2[0:2][::1] 30739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[1:3][::-1] = m2[0:2][::1] 30749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[4:1:-2][::-1] = ex1[1:4:2][::1] 30799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[4:1:-2][::-1] = m1[1:4:2][::1] 30809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_array(self): 30859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def cmptest(testcase, a, b, m, singleitem): 30879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, _ in enumerate(a): 30889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ai = a[i] 30899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mi = m[i] 30909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(ai, mi) 30919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = singleitem 30929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if singleitem != ai: 30939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, m) 30949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, b) 30959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 30969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 30979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, b) 30989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = singleitem 30999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 31009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(b, m) 31019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = ai 31029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = mi 31039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(1, 5): 31059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, singleitem in iter_format(n, 'array'): 31069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(n): 31079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(n): 31089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array(fmt, items) 31109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array(fmt, items) 31119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 31129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 31149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 31159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 31169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), len(a)) 31179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 31199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = None 31219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = None 31229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 31239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah al = a[lslice] 31249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ar = a[rslice] 31259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[lslice] = a[rslice] 31269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = len(al) != len(ar) 31279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 31289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = e.__class__ 31299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = None 31319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 31329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[lslice] = m[rslice] 31339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 31349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = e.__class__ 31359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if have_resize: # memoryview cannot change shape 31379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, ValueError) 31389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif m_err or array_err: 31399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, array_err) 31409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 31419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 31429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 31439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 31449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 31459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 314606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_special_cases(self): 31479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1, 2, 3]) 31499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('L', [1, 2, 7]) 31509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Ordering comparisons raise: 31529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(b) 31549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('__lt__', '__le__', '__gt__', '__ge__'): 31559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(v, attr)(w), NotImplemented) 31569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(a, attr)(v), NotImplemented) 31579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Released views compare equal to themselves: 31599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v.release() 31619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, v) 31629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 31639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 31649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(a) 31679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w.release() 31689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 31699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 31709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Operand does not implement the buffer protocol: 31729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, [1, 2, 3]) 31749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 317506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # NaNs 317606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([(0, 0)], shape=[1], format='l x d x', flags=ND_WRITABLE) 317706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd[0] = (-1, float('nan')) 317806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(memoryview(nd), nd) 31799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 318006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Depends on issue #15625: the struct module does not understand 'u'. 318106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = array.array('u', 'xyz') 31829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 31849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 31859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 318606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Some ctypes format strings are unknown to the struct module. 318706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 318806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 318906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 319006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 319106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 319206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 319306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(point) 319406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 319506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, point) 319606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(point, a) 319706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertRaises(NotImplementedError, a.tolist) 319806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 319906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_zero(self): 32009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(1729, shape=[], format='@L') 32029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(1729, shape=[], format='L', flags=ND_WRITABLE) 32039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 32069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, v) 32079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 32089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd2, v) 32099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 32109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd1, w) 32119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__ne__(w)) 32139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__ne__(v)) 32149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w[()] = 1728 32169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 32179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 32189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 32199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd2, v) 32209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 32219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd1, w) 32229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__eq__(w)) 32249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__eq__(v)) 32259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 32279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 32289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 32299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 32319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[9] = 100 32329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m, nd) 32339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 323406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: equal 323506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 323606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((1729, 1.2, b'12345'), shape=[], format='hf5s', 323706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 323806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 323906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 324006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 324106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, v) 324206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 324306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd2, v) 324406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 324506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd1, w) 324606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 324706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: not equal 324806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 324906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((-1729, 1.2, b'12345'), shape=[], format='hf5s', 325006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 325106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 325206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 325306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 325406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, v) 325506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 325606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd2, v) 325706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 325806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd1, w) 325906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 326006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 326106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 326206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_one(self): 326306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 326406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous 32659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 32669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='@h') 32679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 32719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 32729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 32739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 32749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 32759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 327606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous, struct module 327706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<i') 327806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='>h') 327906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 328006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 328106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 328206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 328306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 328406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 328506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 328606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 328706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 328806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous 32899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 32909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 32919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 32959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 32969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 32979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 32989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 329906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, struct module 330006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='!h') 330106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<l') 330206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 330306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 330406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 330606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 330706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 330806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 330906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 331006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets 33119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 33129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h', 33139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_PIL) 33149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 33189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 33199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 33209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 33219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 332206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets, struct module 332306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='h 0c') 332406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='> h', 332506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 332606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 332706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 332806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 332906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 333006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 333106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 333206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 333306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 333406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_shape(self): 333506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 333606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 33379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 961], shape=[0], format='@h') 33389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-900, -961], shape=[0], format='@h') 33399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 33459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 33469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 33479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 334806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 334906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([900, 961], shape=[0], format='= h0c') 335006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-900, -961], shape=[0], format='@ i') 335106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 335206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 335306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 335406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 335506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 335606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 335706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 335806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 335906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 336006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_strides(self): 336106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 336206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 33639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 900, 900, 900], shape=[4], format='@L') 33649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4], strides=[0], format='L') 33659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 33719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 33729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 33739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 337406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 337506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(900, 900)]*4, shape=[4], format='@ Li') 337606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(900, 900)], shape=[4], strides=[0], format='!L h') 337706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 337806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 337906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 338006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 338106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 338206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 338306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 338406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 338506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 338606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_random_formats(self): 338706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 338806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random single character native formats 33899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 10 33909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@m']: 33919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, singleitem = randitems(n, 'memoryview', '@', char) 33929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 33939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[n], format=fmt, flags=flags) 33949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 33959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 33969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-3] 33989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 33999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 34009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 340106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random formats 340206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan n = 10 340306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for _ in range(100): 340406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan fmt, items, singleitem = randitems(n) 340506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for flags in (0, ND_PIL): 340606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(items, shape=[n], format=fmt, flags=flags) 340706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 340806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 340906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 341006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = nd[::-3] 341106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 341206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 341306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 341406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_c(self): 341506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 341606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values 34179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='@h') 34189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[3, 2, 5], format='@h') 34199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 342806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values, struct module 342906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*30, shape=[3, 2, 5], format='=f q xxL') 343006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1.2, 1, 2)]*30, shape=[3, 2, 5], format='< f 2Q') 343106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 343206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 343306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 343406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 343506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 343606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 343706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 343806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 343906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 344006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape 34419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 34429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='L') 34439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 345206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape, struct module 345306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*21, shape=[3, 7], format='! b B xL') 345406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(0, 1, 2)]*21, shape=[7, 3], format='= Qx l xxL') 34559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 346406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different format, struct module 346506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 346606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[2, 3, 5], format='l') 346706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 346806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 346906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 347006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 347106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 347206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 347306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 347406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 347506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 347606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_fortran(self): 347706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 347806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values 34799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[5, 2, 3], format='@h', 34809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[5, 2, 3], format='@h', 34829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 349206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values, struct module 349306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(2**64-1, -1)]*6, shape=[2, 3], format='=Qq', 349406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 349506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1, 2**64-1)]*6, shape=[2, 3], format='=qQ', 349606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 349706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 349806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 349906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 350006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 350106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 350206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 350306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 350406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 350506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 350606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape 35079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='l', 35089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 35109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 352006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape, struct module 352106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='0ll', 35229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 352306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 35249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 353406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different format, struct module 353506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[5, 2, 3], format='@h', 353606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 353706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 2, 3], format='@b', 353806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 353906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 354006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 354106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 354306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 354406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 354506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 354606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 354706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_mixed(self): 354906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 355006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous 35519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 35529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 35539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l') 35549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN) 35559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 35619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 356206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous, struct module 356306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(-3.3, -22, b'x')]*30 356406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[5] = (-2.2, -22, b'x') 356506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 356606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='d b c') 356706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='d h c', flags=ND_FORTRAN) 356806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 356906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 357006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 357106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 357206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 357306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 357406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 357506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different values, non-contiguous 35769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 35779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 35789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I') 35799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 35809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 358906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # same values, non-contiguous, struct module 359006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='=ii') 359106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 359206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='>ii') 359306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 359406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 359506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 359606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 359706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 359806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 359906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 360006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 360106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 360206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 36039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # different shape 36049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b') 36059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 36069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 36079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 36089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 361706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different shape, struct module 361806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='B') 36199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 362006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 36219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 36229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 363106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different format, struct module 363206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='b3s') 363306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 363406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='i3s') 363506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 363606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 363706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 363806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 363906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 364006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 364106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 364206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 364306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 364406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_shape(self): 364606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 364806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 364906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 365006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 365106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 365206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 365306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 365406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 365506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 365606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 365706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 365806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 365906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 36609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 36619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 36629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 367106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_strides(self): 367206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 367306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 36749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900]*80, shape=[4, 5, 4], format='@L') 36759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4, 5, 4], strides=[0, 0, 0], format='L') 36769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 36829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 36839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 36849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v.tolist(), w.tolist()) 36859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 368606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 368706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(1, 2)]*10, shape=[2, 5], format='=lQ') 368806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(1, 2)], shape=[2, 5], strides=[0, 0], format='<lQ') 368906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 369006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 369106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 369206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 369306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 369406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 369506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 369606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 369706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 369806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_suboffsets(self): 369906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 370006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets 37019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 37029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 37039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I', flags=ND_PIL) 37049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 37059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 371406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, struct module 371506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='=Qq', 371606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 371706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[2][7] = (1, -2) 371806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 371906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='>Qq', 372106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 372206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2[2][7] = (1, -2) 372306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 372406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 372606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 372706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 372906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 373006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 373106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 373206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 373306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 373406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape 373506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b', 373606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 37379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 37389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 37399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 37409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 374906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape, struct module 375006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**8-1, -1)]*40, shape=[2, 3, 5], format='Bb', 375106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 375206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:2:, ::-2] 375306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 375406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**8-1, -1)]*40, shape=[3, 2, 5], format='Bb') 375506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:2:, ::-2] 375606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 375706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 375806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 375906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 376006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 376106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 376206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 376306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 376406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 376506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 376606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format 37679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[5, 3, 2], format='i', flags=ND_PIL) 37689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 376906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray(list(range(30)), shape=[5, 3, 2], format='@I', flags=ND_PIL) 377006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 377106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 377206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 377306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 377406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 377506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 377606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 377706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 377806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 377906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 378006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format, struct module 378106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = 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) 378406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 378506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 378606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP', 378706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 378806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[1][2][2] = (b'sushi', b'', 1) 37899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 379006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 37919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # initialize mixed C/Fortran + suboffsets 38019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 38029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 38039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l', flags=ND_PIL) 38049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN|ND_PIL) 38059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 38069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 38079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 38099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 38109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 38119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 381206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # initialize mixed C/Fortran + suboffsets, struct module 381306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(b'sashimi', b'sliced', 20.05)]*30 381406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[11] = (b'ramen', b'spicy', 9.45) 381506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 381606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 381706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='< 10p 9p d', flags=ND_PIL) 381806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='> 10p 9p d', 381906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN|ND_PIL) 382006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 382106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 382206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 382406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 382506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 382606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_not_equal(self): 382806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # items not equal 383006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for byteorder in ['=', '<', '>', '!']: 383106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q') 383206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q', 383306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE|ND_FORTRAN) 383406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = 1 383506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 383606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 383706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 383806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 383906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 384006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 384106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 384206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 384306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 384406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH') 384506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 384606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH', flags=ND_WRITABLE|ND_FORTRAN) 384706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = (1, 1, 1) 384806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 384906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 385006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 385106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 385206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 385306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 385406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 385506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 38569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_check_released(self): 38579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('d', [1.1, 2.2, 3.3]) 38599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 38619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 38629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromObject() 38649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, m) 38659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.cast() 38669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'c') 38679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getbuffer() 38689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ndarray, m) 38699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tolist() 38709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tolist) 38719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tobytes() 38729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tobytes) 38739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # sequence 38749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, eval, "1.0 in m", locals()) 38759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # subscript 38769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, 0) 38779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assignment 38789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, 0, 1) 38799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('obj', 'nbytes', 'readonly', 'itemsize', 'format', 'ndim', 38819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'shape', 'strides', 'suboffsets', 'c_contiguous', 38829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f_contiguous', 'contiguous'): 38839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getattribute__, attr) 38849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # richcompare 38869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('d', [1.1, 2.2, 3.3]) 38879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 38889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(b) 38899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m2) 38919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 38929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, m2) 38939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, a) 38949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m1) 38959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tobytes(self): 38979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 38989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 389906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan t = (-529, 576, -625, 676, -729) 39009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 390106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(t, shape=[5], format='@h') 39029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 390306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 39049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), nd.tobytes()) 39059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 390606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t], shape=[1], 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(12)], shape=[2,2,3], format='=hQiLl') 391206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 391306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 391406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 391506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 391606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t for _ in range(120)], shape=[5,2,2,3,2], 391706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format='<hQiLl') 391806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 391906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 392006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 392106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 392206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Unknown formats are handled: tobytes() purely depends on itemsize. 392306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 392406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 392506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 392606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 392706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 392806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 392906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a.tobytes(), bytes(point)) 393006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 39319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_get_contiguous(self): 39329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 39339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # no buffer interface 39359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, {}, PyBUF_READ, 'F') 39369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to read-only object 39389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, b'x', PyBUF_WRITE, 'C') 39399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to non-contiguous object 39419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2]) 39429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'A') 39439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from read-only exporter 39459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L") 39469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from writable exporter 39529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 39539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, writable request 39599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9 39619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 10 39669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 10) 39679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[()], 10) 39689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 39709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 39719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 0) 39749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), []) 39769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 39789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 39799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), [[], []]) 39829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 39849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], format="h", flags=ND_WRITABLE) 39859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=ND_WRITABLE) 39919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional, non-contiguous 39979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 39989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 40019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 40029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 40039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 3) 40049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 3) 40059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-1] 40079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 40089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 40109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 40119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 40129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 1) 40139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 1) 40149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, contiguous input 40169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE) 40179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'A']: 40189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 40199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'F') 40229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], 40269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|ND_FORTRAN) 40279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['F', 'A']: 40289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 40299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'C') 40329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, non-contiguous input 40369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 40379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 40389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 40399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah order) 40409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags 40449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3,4,5], shape=[3], strides=[2]) 40459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, 'C') 40469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 40479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_serializing(self): 40499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 40519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('i') 40529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('i', [1,2,3,4,5]) 40539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 40549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 40559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(5*size) 40569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 40579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 40589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous, multi-dimensional 40609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('L') 40619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], format="L") 40629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 40649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(2*3*2*size) 40659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 40669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 40679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous, multi-dimensional 40699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #size = struct.calcsize('L') 40709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #nd = ndarray(list(range(12)), shape=[2,3,2], format="L", 40719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags=ND_FORTRAN) 40729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #m = memoryview(nd) 40739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf = io.BytesIO(m) 40749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #b = bytearray(2*3*2*size) 40759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf.readinto(b) 40769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #self.assertEqual(m.tobytes(), b) 40779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_hash(self): 40799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # bytes exporter 40819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 40829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 40839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(b), hash(m)) 40849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 40869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mc = m.cast('c', shape=[3,4]) 40879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mc), hash(b)) 40889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous 40909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mx = m[::-2] 40919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))[::-2]) 40929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mx), hash(b)) 40939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 40959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5], flags=ND_FORTRAN) 40969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(nd)) 40989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice 41009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5]) 41019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 41029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 41039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 41049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice with suboffsets 41069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[2,5,3], flags=ND_PIL) 41079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 41089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 41099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 41109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41114af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah # equality-hash invariant 41124af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah x = ndarray(list(range(12)), shape=[12], format='B') 4113b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah a = memoryview(x) 41144af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41154af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah y = ndarray(list(range(12)), shape=[12], format='b') 4116b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah b = memoryview(y) 41174af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 4118b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(a, b) 4119b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(hash(a), hash(b)) 41204af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 41229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 41239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 41244af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='h') 41279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 41284af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41294af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41304af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='= L') 41314af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 41324af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41334af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41344af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='< h') 41354af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 41364af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_release(self): 41399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create re-exporter from getbuffer(memoryview), then release the view. 41419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 41429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 41439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m) # re-exporter 41449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m.release) 41459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 41479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41484e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 41494e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(a) 41504e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41514e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41524e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m) 41534e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m.release) 41544e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 41554e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m.release() 41564e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # chained views 41589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 41599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 41609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m1) 41619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m2) # re-exporter 41629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 41639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m2.release) 41649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 41669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 41684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1 = memoryview(a) 41694e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2 = memoryview(m1) 41704e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41714e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41724e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m2) 41734e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1.release() 41744e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m2.release) 41754e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 41764e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2.release() 41774e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Allow changing layout while buffers are exported. 41799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 41809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 41819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([4,5,6,7,8], shape=[5]) # mutate nd 41839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 41849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = memoryview(m1) 41869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), m1.tolist()) 41879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = memoryview(m2) 41899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), m2.tolist()) 41909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), nd.tolist()) 41919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 41929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y.release() 41939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() # pop the current view 41959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), nd.tolist()) 41969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 41999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x.release() 42009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # If multiple memoryviews share the same managed buffer, implicit 42029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # release() in the context manager's __exit__() method should still 42039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # work. 42049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def catch22(b): 42059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(b) as m2: 42069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 42079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bytearray(b'123') 42099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(x) as m1: 42109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah catch22(m1) 42119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1[0], ord(b'1')) 42129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42134e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = ndarray(list(range(12)), shape=[2,2,3], format='l') 42144e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42154e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42164e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 42174e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m: 42184e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m) 42194e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[0:1].tolist(), [[[0, 1, 2], [3, 4, 5]]]) 42204e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42214e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah # Test garbage collection. 42224e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for flags in (0, ND_REDIRECT): 42234e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 42244e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 42254e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 42264e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 42274e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 42284e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 42294e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 42304e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 42314e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 42324e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 42334e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 42344e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 42354e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 42364e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 42374e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 42384e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m3 42394e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m2 42404e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1 42414e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42424e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 42434e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 42444e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 42454e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 42464e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 42474e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 42484e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 42494e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 42504e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 42514e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 42524e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 42534e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 42544e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 42554e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 42564e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 42574e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1, m2, m3 42584e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4259fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah # memoryview.release() fails if the view has exported buffers. 4260fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah x = bytearray(b'123') 4261fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with self.assertRaises(BufferError): 4262fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with memoryview(x) as m: 4263fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah ex = ndarray(m) 4264fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah m[0] == ord(b'1') 42659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42664e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah def test_memoryview_redirect(self): 42674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd = ndarray([1.0 * x for x in range(12)], shape=[12], format='d') 42694e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = array.array('d', [1.0 * x for x in range(12)]) 42704e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42714e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for x in (nd, a): 42724e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42734e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42744e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(z) 42754e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42764e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(y.obj, x) 42774e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 42784e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(m.obj, x) 42794e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42804e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, x) 42814e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, y) 42824e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, z) 42834e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42844e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 42854e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], y[1:3]) 42864e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], z[1:3]) 42874e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y, z 42884e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 42894e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4290bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah def test_memoryview_from_static_exporter(self): 4291bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4292bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah fmt = 'B' 4293bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst = [0,1,2,3,4,5,6,7,8,9,10,11] 4294bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4295bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # exceptions 4296bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertRaises(TypeError, staticarray, 1, 2, 3) 4297bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4298bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==x 4299bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4300bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4301bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=x, 4302bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4303bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4304bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4305bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4306bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4307bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4308bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4309bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4310bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4311bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4312bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4313bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4314bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4315bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4316bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4317bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4318bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4319bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4320bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4321bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4322bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4323bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4324bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4325bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4326bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4327bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4328bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4329bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4330bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4331bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4332bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, x) 4333bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, x) 4334bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=x, 4335bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4336bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4337bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4338bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4339bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4340bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==NULL 4341bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4342bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4343bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=None, 4344bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4345bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4346bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4347bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4348bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4349bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4350bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4351bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4352bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4353bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4354bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4355bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4356bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4357bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4358bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4359bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4360bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4361bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4362bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4363bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4364bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4365bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4366bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4367bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4368bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4369bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4370bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4371bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4372bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4373bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # Clearly setting view.obj==NULL is inferior, since it 4374bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # messes up the redirection chain: 4375bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4376bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, y) 4377bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, y) 4378bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=y, 4379bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4380bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4381bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4382bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4383bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 43841649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah def test_memoryview_getbuffer_undefined(self): 43851649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 43861649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah # getbufferproc does not adhere to the new documentation 43871649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah nd = ndarray([1,2,3], [3], flags=ND_GETBUF_FAIL|ND_GETBUF_UNDEFINED) 43881649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah self.assertRaises(BufferError, memoryview, nd) 43891649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 43909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_issue_7385(self): 43919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1,2,3], shape=[3], flags=ND_GETBUF_FAIL) 43929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, x) 43939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 43949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 43959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif __name__ == "__main__": 43963e9a9ae09d6fc9169b01cba3efd1ae03ab40b237Brett Cannon unittest.main() 4397