def __init__(self, path): ex = Excel.ApplicationClass() ex.Visible = False lst_xls = [] workbook = ex.Workbooks.Open(path) ws = workbook.Worksheets[1] rowCountF = max(ws.Range(i).End(xlDirecUp).Row for i in ["A65536", "B65536", "C65536", "D65536", "E65536", "F65536", "G65536", "H65536"]) # other method if column A is empty # rowCountF = ws.Range("B65536").End(xlDirecUp).Row # rowCountF = ws.Columns[1].End(xlDirecDown).Row ##get number of Coloun not empty ## colCountF = max(ws.Range(i).End(xlDirecLeft).Column for i in ["ZZ1", "ZZ2", "ZZ3", "ZZ4", "ZZ5", "ZZ6", "ZZ7", "ZZ8", "ZZ9"]) # other methods #colCountF = ws.Range("ZZ9").End(xlDirecLeft).Column # colCountF = ws.Rows[1].End(xlDirecRight).Column for i in range(1,rowCountF+1): temp_lst = [] for j in range(1,colCountF+1): try: temp_lst.append(ws.Cells[i,j].Value2.ToString()) except: temp_lst.append(ws.Cells[i,j].Value2) lst_xls.append(temp_lst) self.datas = lst_xls self.first_flst = [x for x in lst_xls[0]] # or lst_xls[0] #Get the specify index self.type_fidx = self.first_flst.index("Type") ex.Workbooks.Close() ex.Quit() #other proper way to make sure that you really closed and released all COM objects Marshal.ReleaseComObject(workbook) Marshal.ReleaseComObject(ex)
def testStoreSameObjectIncRefsOriginal(self): frees = [] allocs = [] mapper = PythonMapper(GetAllocatingTestAllocator(allocs, frees)) deallocTypes = CreateTypes(mapper) del allocs[:] obj1 = object() result1 = mapper.Store(obj1) result2 = mapper.Store(obj1) self.assertEquals(allocs, [(result1, Marshal.SizeOf(PyObject))], "unexpected result") self.assertEquals(result1, result2, "did not return same ptr") self.assertEquals(mapper.RefCount(result1), 2, "did not incref") mapper.DecRef(result1) del frees[:] mapper.DecRef(result1) self.assertEquals(frees, [result1], "did not free memory") result3 = mapper.Store(obj1) self.assertEquals( allocs, [(result1, Marshal.SizeOf(PyObject)), (result3, Marshal.SizeOf(PyObject))], "unexpected result -- failed to clear reverse mapping?") mapper.Dispose() deallocTypes()
def testInternExisting(self, mapper, addToCleanUp): testString = "mars needs women" + self.getStringWithValues(1, 256) bytes = self.byteArrayFromString(testString) testData = self.ptrFromByteArray(bytes) sp1 = mapper.PyString_FromString(testData) addToCleanUp(lambda: Marshal.FreeHGlobal(sp1p)) sp2 = mapper.PyString_InternFromString(testData) addToCleanUp(lambda: Marshal.FreeHGlobal(testData)) self.assertNotEquals(sp1, sp2) self.assertFalse(mapper.Retrieve(sp1) is mapper.Retrieve(sp2)) self.assertEquals(mapper.RefCount(sp1), 1) self.assertEquals( mapper.RefCount(sp2), 2, 'failed to grab extra reference to induce immortality') mapper.IncRef(sp1) sp1p = Marshal.AllocHGlobal(Marshal.SizeOf(IntPtr)) CPyMarshal.WritePtr(sp1p, sp1) mapper.PyString_InternInPlace(sp1p) sp1i = CPyMarshal.ReadPtr(sp1p) self.assertEquals(sp1i, sp2, 'failed to intern') self.assertTrue(mapper.Retrieve(sp1i) is mapper.Retrieve(sp2)) self.assertEquals(mapper.RefCount(sp1), 1, 'failed to decref old string') self.assertEquals(mapper.RefCount(sp2), 3, 'failed to incref interned string')
def CleanUp(_list): if isinstance(_list, list): for i in _list: Marshal.ReleaseComObject(i) else: Marshal.ReleaseComObject(_list) return None
def excelWorkbookAction(workbook): worksheets = workbook.Worksheets worksheet = worksheets[worksheetName] if worksheetName is not None else worksheets[1] WriteRowsToWorksheet(worksheet, rows) Marshal.FinalReleaseComObject(worksheet) Marshal.FinalReleaseComObject(worksheets) return
def testStoreTypeDictCreatesDictTypeWhichWorks(self, mapper, addToCleanUp): typeBlock = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject)) addToCleanUp(lambda: Marshal.FreeHGlobal(typeBlock)) mapper.RegisterData("PyDict_Type", typeBlock) class klass(object): pass dictPtr = mapper.Store(klass.__dict__) self.assertEquals( CPyMarshal.ReadPtrField(dictPtr, PyObject, "ob_type"), typeBlock, "wrong type") self.assertEquals( mapper.PyDict_SetItemString(dictPtr, 'foo', mapper.Store('bar')), 0) self.assertEquals( mapper.PyDict_SetItem(dictPtr, mapper.Store('baz'), mapper.Store('qux')), 0) self.assertEquals( mapper.Retrieve(mapper.PyDict_GetItemString(dictPtr, 'foo')), 'bar') self.assertEquals( mapper.Retrieve(mapper.PyDict_GetItem(dictPtr, mapper.Store('baz'))), 'qux') self.assertEquals(klass.foo, 'bar') self.assertEquals(klass.baz, 'qux') self.assertEquals(mapper.PyDict_Size(dictPtr), len(klass.__dict__))
def closeProperly(self): if self.workbook is not None: Marshal.ReleaseComObject(self.workbook) if self.app is not None: Marshal.ReleaseComObject(self.app) self.workbook = None self.app = None
def excelWorkbookAction(workbook): worksheets = workbook.Worksheets worksheet = worksheets[worksheetName] if worksheetName is not None else worksheets[1] rows = ReadRowsTextFromWorksheet(worksheet) Marshal.FinalReleaseComObject(worksheet) Marshal.FinalReleaseComObject(worksheets) return rows
def testPyType_Ready(self, mapper, addToCleanUp): typePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject())) CPyMarshal.Zero(typePtr, Marshal.SizeOf(PyTypeObject())) addToCleanUp(lambda: Marshal.FreeHGlobal(typePtr)) self.assertEquals(mapper.PyType_Ready(typePtr), 0, "wrong") self.assertEquals( CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "ob_type"), mapper.PyType_Type, "failed to fill in missing ob_type") self.assertEquals( CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "tp_base"), mapper.PyBaseObject_Type, "failed to fill in missing tp_base") tp_dict = mapper.Retrieve( CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "tp_dict")) self.assertEquals(mapper.Retrieve(typePtr).__dict__, tp_dict) typeFlags = CPyMarshal.ReadIntField(typePtr, PyTypeObject, "tp_flags") self.assertEquals(typeFlags & UInt32(Py_TPFLAGS.READY), UInt32(Py_TPFLAGS.READY), "did not ready type") self.assertEquals( typeFlags & UInt32(Py_TPFLAGS.HAVE_CLASS), UInt32(Py_TPFLAGS.HAVE_CLASS), "we always set this flag, for no better reason than 'it makes ctypes kinda work'" ) CPyMarshal.WritePtrField(typePtr, PyTypeObject, "ob_type", IntPtr.Zero) self.assertEquals(mapper.PyType_Ready(typePtr), 0, "wrong") self.assertEquals( CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "ob_type"), IntPtr.Zero, "unexpectedly and unnecessarily rereadied type")
def closeProperly(self): if self.document is not None: Marshal.ReleaseComObject(self.document) if self.wapp is not None: Marshal.ReleaseComObject(self.wapp) self.document = None self.wapp = None
def testPyList_New_NonZeroLength(self): allocs = [] mapper = PythonMapper(GetAllocatingTestAllocator(allocs, [])) deallocTypes = CreateTypes(mapper) del allocs[:] SIZE = 27 listPtr = mapper.PyList_New(SIZE) listStruct = Marshal.PtrToStructure(listPtr, PyListObject) self.assertEquals(listStruct.ob_refcnt, 1, "bad refcount") self.assertEquals(listStruct.ob_type, mapper.PyList_Type, "bad type") self.assertEquals(listStruct.ob_size, SIZE, "bad ob_size") self.assertEquals(listStruct.allocated, SIZE, "bad allocated") dataPtr = listStruct.ob_item self.assertNotEquals(dataPtr, IntPtr.Zero, "failed to allocate space for data") expectedAllocs = [(dataPtr, (SIZE * CPyMarshal.PtrSize)), (listPtr, Marshal.SizeOf(PyListObject))] self.assertEquals(set(allocs), set(expectedAllocs), "allocated wrong") for _ in range(SIZE): self.assertEquals(CPyMarshal.ReadPtr(dataPtr), IntPtr.Zero, "failed to zero memory") dataPtr = OffsetPtr(dataPtr, CPyMarshal.PtrSize) mapper.Dispose() deallocTypes()
def __enter__(self): #$if $$notdemo global EPLATFORMCLASS with threading.RLock(): # Без этого не работает. Нужно разбираться. self.ad = self.ent.like_dispatch.GetType().InvokeMember( 'AppDispatch', BindingFlags.Public | BindingFlags.GetProperty, None, self.ent.like_dispatch, None) try: self.ad.GetType() except: EPLATFORMCLASS = 8 else: EPLATFORMCLASS = 7 Marshal.GetIUnknownForObject(self.ad) #$else with threading.RLock(): # Без этого не работает. Нужно разбираться. # self.ad = self.ent.like_dispatch.GetType().InvokeMember('AppDispatch', BindingFlags.Public | BindingFlags.InvokeMethod, None, self.ent.like_dispatch, None) self.ad = self.ent.like_dispatch.GetType().InvokeMember( 'AppDispatch', BindingFlags.Public | BindingFlags.GetProperty, None, self.ent.like_dispatch, None) Marshal.GetIUnknownForObject(self.ad) #$end if UseAppDispatch.counter += 1 return self.ad
def xlr2list(xlrange): """Converts excel range to python list """ rows = xlrange.Rows columns = xlrange.Columns n = rows.Count m = columns.Count vals = [[0] * m for i in range(n)] for i in range(n): for j in range(m): tmp = xlrange[i + 1, j + 1].Value2 try: if int(tmp) == tmp: tmp = int(tmp) except: # tmp = tmp.unicode('utf8') pass # print tmp vals[i][j] = tmp Marshal.FinalReleaseComObject(rows) Marshal.FinalReleaseComObject(columns) Marshal.FinalReleaseComObject(xlrange) rows = None columns = None xlrange = None return vals
def testStoreTupleCreatesTupleType(self): allocs = [] mapper = PythonMapper(GetAllocatingTestAllocator(allocs, [])) typeBlock = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject())) mapper.RegisterData("PyTuple_Type", typeBlock) theTuple = (0, 1, 2) tuplePtr = mapper.Store(theTuple) self.assertEquals( CPyMarshal.ReadPtrField(tuplePtr, PyTupleObject, "ob_type"), typeBlock, "wrong type") dataPtr = OffsetPtr(tuplePtr, Marshal.OffsetOf(PyTupleObject, "ob_item")) for i in range(3): item = mapper.Retrieve(CPyMarshal.ReadPtr(dataPtr)) self.assertEquals(item, i, "did not store data") dataPtr = OffsetPtr(dataPtr, CPyMarshal.PtrSize) tuplePtr2 = mapper.Store(theTuple) self.assertEquals(tuplePtr2, tuplePtr, "didn't realise already had this tuple") self.assertEquals(mapper.RefCount(tuplePtr), 2, "didn't incref") mapper.Dispose() Marshal.FreeHGlobal(typeBlock)
def readFromDatasetWithCompoundType(dset): mtype = createMemType() sizeof = H5T.getSize(mtype) dspace = H5D.getSpace(dset) npoints = H5S.getSimpleExtentNPoints(dspace) shape = Array[Int64]((npoints * sizeof, )) byteArray = Array.CreateInstance(Byte, shape) H5D.read(dset, mtype, H5Array[Byte](byteArray)) ms = MemoryStream(byteArray) reader = BinaryReader(ms) for i in range(npoints): if IntPtr.Size == 8: print '%d,%s,%.2f,%.2f' % (reader.ReadInt32( ), Marshal.PtrToStringAnsi(IntPtr( reader.ReadInt64())), reader.ReadDouble(), reader.ReadDouble()) else: print '%d,%s,%.2f,%.2f' % (reader.ReadInt32( ), Marshal.PtrToStringAnsi(IntPtr( reader.ReadInt32())), reader.ReadDouble(), reader.ReadDouble()) H5S.close(dspace) H5T.close(mtype) return None
def testBufferProtocol(self, mapper, later): # should all be implemented in C really, but weaving cpy string type into # our code feels too much like hard work for now strPtr = mapper.PyString_Type bufPtr = CPyMarshal.ReadPtrField(strPtr, PyTypeObject, 'tp_as_buffer') self.assertNotEquals(bufPtr, IntPtr.Zero) getreadbuffer = CPyMarshal.ReadFunctionPtrField( bufPtr, PyBufferProcs, 'bf_getreadbuffer', dgt_int_ptrintptr) getwritebuffer = CPyMarshal.ReadFunctionPtrField( bufPtr, PyBufferProcs, 'bf_getwritebuffer', dgt_int_ptrintptr) getcharbuffer = CPyMarshal.ReadFunctionPtrField( bufPtr, PyBufferProcs, 'bf_getcharbuffer', dgt_int_ptrintptr) getsegcount = CPyMarshal.ReadFunctionPtrField(bufPtr, PyBufferProcs, 'bf_getsegcount', dgt_int_ptrptr) ptrptr = Marshal.AllocHGlobal(Marshal.SizeOf(IntPtr)) later(lambda: Marshal.FreeHGlobal(ptrptr)) strptr = mapper.Store("hullo") for getter in (getreadbuffer, getcharbuffer): self.assertEquals(getter(strptr, 0, ptrptr), 5) self.assertEquals( CPyMarshal.ReadPtr(ptrptr), CPyMarshal.GetField(strptr, PyStringObject, 'ob_sval')) self.assertEquals(getter(strptr, 1, ptrptr), -1) self.assertMapperHasError(mapper, SystemError) self.assertEquals(getwritebuffer(strptr, 0, ptrptr), -1) self.assertMapperHasError(mapper, SystemError) self.assertEquals(getsegcount(strptr, ptrptr), 1) self.assertEquals(CPyMarshal.ReadInt(ptrptr), 5) self.assertEquals(getsegcount(strptr, IntPtr.Zero), 1)
def testTrueFalse(self, mapper, _): truePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyIntObject)) mapper.RegisterData("_Py_TrueStruct", truePtr) self.assertTrue(mapper.Retrieve(truePtr) is True) self.assertEquals( CPyMarshal.ReadPtrField(truePtr, PyIntObject, 'ob_type'), mapper.PyBool_Type) self.assertEquals( CPyMarshal.ReadIntField(truePtr, PyIntObject, 'ob_refcnt'), 1) self.assertEquals( CPyMarshal.ReadIntField(truePtr, PyIntObject, 'ob_ival'), 1) truePtr2 = mapper.Store(True) self.assertEquals(truePtr2, truePtr) self.assertEquals(mapper.RefCount(truePtr), 2) falsePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyIntObject)) mapper.RegisterData("_Py_ZeroStruct", falsePtr) self.assertTrue(mapper.Retrieve(falsePtr) is False) self.assertEquals( CPyMarshal.ReadPtrField(falsePtr, PyIntObject, 'ob_type'), mapper.PyBool_Type) self.assertEquals( CPyMarshal.ReadIntField(falsePtr, PyIntObject, 'ob_refcnt'), 1) self.assertEquals( CPyMarshal.ReadIntField(falsePtr, PyIntObject, 'ob_ival'), 0) falsePtr2 = mapper.Store(False) self.assertEquals(falsePtr2, falsePtr) self.assertEquals(mapper.RefCount(falsePtr), 2)
def testPyFile_Type(self, mapper, addToCleanUp): typeBlock = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject)) addToCleanUp(lambda: Marshal.FreeHGlobal(typeBlock)) mapper.RegisterData("PyFile_Type", typeBlock) self.assertEquals(mapper.PyFile_Type, typeBlock, "type address not stored") self.assertEquals(mapper.Retrieve(typeBlock), file, "type not mapped")
def excel_read(origin = "A3", worksheetname="Levels"): try: xlapp = Marshal.GetActiveObject('Excel.Application') ws = xlapp.sheets(worksheetname) #Name of the Excel Worksheet except EnvironmentError: try: filepath = pick_file(file_ext='*') except: sys.exit() os.startfile(filepath) from time import sleep sleep(1) try: xlapp = Marshal.GetActiveObject('Excel.Application') ws = xlapp.sheets(worksheetname) #Name of the Excel Worksheet except: forms.alert('Excel Application not open!\nOpen Excel file with worksheet "Levels" ') dialogexcelnotopen.show() sys.exit() except: print("Error") import traceback print(traceback.format_exc()) extent = ws.Cells(ws.UsedRange.Rows(ws.UsedRange.Rows.Count).Row, ws.UsedRange.Columns(ws.UsedRange.Columns.Count).Column) xlrng = ws.Range[origin, extent].Value2 # 2dimensional array data_list = [[] for i in range(xlrng.GetUpperBound(0))] for i in range(xlrng.GetLowerBound(0)-1, xlrng.GetUpperBound(0), 1): for j in range(xlrng.GetLowerBound(1)-1, xlrng.GetUpperBound(1), 1): data_list[i].append(xlrng[i,j]) Marshal.ReleaseComObject(xlapp) return data_list
def testShrink(self): allocs = [] frees = [] mapper = PythonMapper(GetAllocatingTestAllocator(allocs, frees)) deallocTypes = CreateTypes(mapper) del allocs[:] oldLength = 365 newLength = 20 ptrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(IntPtr)) try: strPtr = mapper.PyString_FromStringAndSize(IntPtr.Zero, oldLength) Marshal.WriteIntPtr(ptrPtr, strPtr) baseSize = Marshal.SizeOf(PyStringObject) self.assertEquals(allocs, [(strPtr, oldLength + baseSize)], "allocated wrong") self.assertEquals(mapper._PyString_Resize(ptrPtr, newLength), 0, "bad return on success") self.assertHasStringType(strPtr, mapper) self.assertStringObjectHasLength(strPtr, newLength) self.assertEquals(allocs, [(strPtr, oldLength + baseSize)], "unexpected extra alloc") self.assertEquals(frees, [], "unexpected frees") finally: mapper.Dispose() Marshal.FreeHGlobal(ptrPtr) deallocTypes()
def test_PyTuple_Resize_TooBig(self, mapper, addDealloc): tuplePtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize) addDealloc(lambda: Marshal.FreeHGlobal(tuplePtrPtr)) tuplePtr = mapper.PyTuple_New(1) CPyMarshal.WritePtr(tuplePtrPtr, tuplePtr) self.assertEquals(mapper._PyTuple_Resize(tuplePtrPtr, 2000000000), -1) self.assertEquals(CPyMarshal.ReadPtr(tuplePtrPtr), IntPtr.Zero)
def testActualiseFloat(self, mapper, call_later): fptr = Marshal.AllocHGlobal(Marshal.SizeOf(PyFloatObject)) call_later(lambda: Marshal.FreeHGlobal(fptr)) CPyMarshal.WritePtrField(fptr, PyFloatObject, "ob_type", mapper.PyFloat_Type) CPyMarshal.WriteIntField(fptr, PyFloatObject, "ob_refcnt", 1) CPyMarshal.WriteDoubleField(fptr, PyFloatObject, "ob_fval", 1.234) self.assertEquals(mapper.Retrieve(fptr), 1.234)
def testReadDouble(self): data = Marshal.AllocHGlobal(CPyMarshal.DoubleSize) doubleStruct = DoubleStruct(2.2e22) Marshal.StructureToPtr(doubleStruct, data, False) self.assertEquals(CPyMarshal.ReadDouble(data), 2.2e22) Marshal.FreeHGlobal(data)
def testWriteDouble(self): data = Marshal.AllocHGlobal(CPyMarshal.DoubleSize) CPyMarshal.WriteDouble(data, 2.2e22) doubleStruct = PtrToStructure(data, DoubleStruct) self.assertEquals(doubleStruct.value, 2.2e22) Marshal.FreeHGlobal(data)
def testIgnoresBridgeObjectsNotAllocatedByAllocator(self): obj = object() ptr = Marshal.AllocHGlobal(Marshal.SizeOf(PyObject)) CPyMarshal.WriteIntField(ptr, PyObject, 'ob_refcnt', 2) mapper = PythonMapper() mapper.StoreBridge(ptr, obj) mapper.Dispose()
def testPyType_IsSubtype_NullPtrs(self, mapper, CallLater): type_size = Marshal.SizeOf(PyTypeObject) ptr = Marshal.AllocHGlobal(type_size) CallLater(lambda: Marshal.FreeHGlobal(ptr)) CPyMarshal.Zero(ptr, type_size) self.assertTrue(mapper.PyType_IsSubtype(ptr, mapper.PyBaseObject_Type)) self.assertTrue(mapper.PyType_IsSubtype(ptr, ptr))
def testFills(self, mapper, addToCleanUp): # TODO: if we set a lower value, numpy will crash inside arr_add_docstring # I consider docstrings to be low-priority-enough that it's OK to fudge this # for now. also, fixing it would be hard ;). flagPtr = Marshal.AllocHGlobal(Marshal.SizeOf(Int32)) addToCleanUp(lambda: Marshal.FreeHGlobal(flagPtr)) mapper.RegisterData("Py_OptimizeFlag", flagPtr) self.assertEquals(CPyMarshal.ReadInt(flagPtr), 2)
def testWriteDoubleField(self): data = Marshal.AllocHGlobal(Marshal.SizeOf(PyFloatObject())) CPyMarshal.Zero(data, Marshal.SizeOf(PyFloatObject())) CPyMarshal.WriteDoubleField(data, PyFloatObject, "ob_fval", 7.6e-5) dataStruct = PtrToStructure(data, PyFloatObject) self.assertEquals(dataStruct.ob_fval, 7.6e-5) Marshal.FreeHGlobal(data)
def testWorksWithNonString(self, mapper, addDealloc): dataPtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 2) sizePtr = CPyMarshal.Offset(dataPtrPtr, CPyMarshal.PtrSize) addDealloc(lambda: Marshal.FreeHGlobal(dataPtrPtr)) self.assertEquals( mapper.PyString_AsStringAndSize(mapper.Store(object()), dataPtrPtr, sizePtr), -1) self.assertMapperHasError(mapper, TypeError)
def testWritePtrField(self): data = Marshal.AllocHGlobal(Marshal.SizeOf(PyObject())) CPyMarshal.Zero(data, Marshal.SizeOf(PyObject())) CPyMarshal.WritePtrField(data, PyObject, "ob_type", IntPtr(12345)) dataStruct = PtrToStructure(data, PyObject) self.assertEquals(dataStruct.ob_type, IntPtr(12345), "failed to write") Marshal.FreeHGlobal(data)