From 95f28ab76f0a6931bdb109ea721105f79a60ff33 Mon Sep 17 00:00:00 2001 From: "Mike C. Fletcher" Date: Wed, 31 Aug 2022 18:16:27 -0400 Subject: [PATCH] LOGGING Lower logging messages to debug for not-particularly-actionable reports --- OpenGL/acceleratesupport.py | 2 +- OpenGL/arrays/arraydatatype.py | 333 +++++++++++++++++++-------------- 2 files changed, 192 insertions(+), 143 deletions(-) diff --git a/OpenGL/acceleratesupport.py b/OpenGL/acceleratesupport.py index 6cf3fb01..5dab688d 100644 --- a/OpenGL/acceleratesupport.py +++ b/OpenGL/acceleratesupport.py @@ -16,7 +16,7 @@ ) raise ImportError("""Old version of OpenGL_accelerate""") ACCELERATE_AVAILABLE = True - _log.info("""OpenGL_accelerate module loaded""") + _log.debug("""OpenGL_accelerate module loaded""") else: raise ImportError("""Acceleration disabled""") except ImportError as err: diff --git a/OpenGL/arrays/arraydatatype.py b/OpenGL/arrays/arraydatatype.py index 8f030864..82fa0c22 100644 --- a/OpenGL/arrays/arraydatatype.py +++ b/OpenGL/arrays/arraydatatype.py @@ -1,83 +1,87 @@ """Array data-type implementations (abstraction points for GL array types""" import ctypes import OpenGL + assert OpenGL from OpenGL.raw.GL import _types from OpenGL import plugins from OpenGL.arrays import formathandler, _arrayconstants as GL_1_1 from OpenGL import logs -_log = logs.getLog( 'OpenGL.arrays.arraydatatype' ) + +_log = logs.getLog("OpenGL.arrays.arraydatatype") try: unicode except NameError: unicode = str from OpenGL import acceleratesupport + ADT = None if acceleratesupport.ACCELERATE_AVAILABLE: try: from OpenGL_accelerate.arraydatatype import ArrayDatatype as ADT except ImportError as err: - _log.warning( - "Unable to load ArrayDatatype accelerator from OpenGL_accelerate" - ) + _log.warning("Unable to load ArrayDatatype accelerator from OpenGL_accelerate") if ADT is None: # Python-coded version - class HandlerRegistry( dict ): - GENERIC_OUTPUT_PREFERENCES = ['numpy','ctypesarrays'] - def __init__( self, plugin_match ): + class HandlerRegistry(dict): + GENERIC_OUTPUT_PREFERENCES = ["numpy", "ctypesarrays"] + + def __init__(self, plugin_match): self.match = plugin_match - self.output_handler = None + self.output_handler = None self.preferredOutput = None self.all_output_handlers = [] - def __call__( self, value ): + + def __call__(self, value): """Lookup of handler for given value""" try: typ = value.__class__ except AttributeError: typ = type(value) - handler = self.get( typ ) + handler = self.get(typ) if not handler: - if hasattr( typ, '__mro__' ): + if hasattr(typ, "__mro__"): for base in typ.__mro__: - handler = self.get( base ) + handler = self.get(base) if not handler: - handler = self.match( base ) + handler = self.match(base) if handler: handler = handler.load() if handler: handler = handler() if handler: - self[ typ ] = handler - if hasattr( handler, 'registerEquivalent' ): - handler.registerEquivalent( typ, base ) + self[typ] = handler + if hasattr(handler, "registerEquivalent"): + handler.registerEquivalent(typ, base) return handler print(self.keys()) raise TypeError( - """No array-type handler for type %s.%s (value: %s) registered"""%( - typ.__module__, typ.__name__, repr(value)[:50] - ) + """No array-type handler for type %s.%s (value: %s) registered""" + % (typ.__module__, typ.__name__, repr(value)[:50]) ) return handler - - def handler_by_plugin_name( self, name ): - plugin = plugins.FormatHandler.by_name( name ) + + def handler_by_plugin_name(self, name): + plugin = plugins.FormatHandler.by_name(name) if plugin: try: return plugin.load() except ImportError: return None else: - raise RuntimeError( 'No handler of name %s found'%(name,)) - - def get_output_handler( self ): + raise RuntimeError("No handler of name %s found" % (name,)) + + def get_output_handler(self): """Fast-path lookup for output handler object""" if self.output_handler is None: if self.preferredOutput is not None: - self.output_handler = self.handler_by_plugin_name( self.preferredOutput ) + self.output_handler = self.handler_by_plugin_name( + self.preferredOutput + ) if not self.output_handler: for preferred in self.GENERIC_OUTPUT_PREFERENCES: - self.output_handler = self.handler_by_plugin_name( preferred ) + self.output_handler = self.handler_by_plugin_name(preferred) if self.output_handler: break if not self.output_handler: @@ -85,239 +89,284 @@ def get_output_handler( self ): """Unable to find any output handler at all (not even ctypes/numpy ones!)""" ) return self.output_handler - - def register( self, handler, types=None ): + + def register(self, handler, types=None): """Register this class as handler for given set of types""" - if not isinstance( types, (list,tuple)): - types = [ types ] + if not isinstance(types, (list, tuple)): + types = [types] for type in types: - self[ type ] = handler + self[type] = handler if handler.isOutput: - self.all_output_handlers.append( handler ) - - def registerReturn( self, handler ): + self.all_output_handlers.append(handler) + + def registerReturn(self, handler): """Register this handler as the default return-type handler""" - if isinstance( handler, (str,unicode)): - self.preferredOutput = handler + if isinstance(handler, (str, unicode)): + self.preferredOutput = handler self.output_handler = None else: - self.preferredOutput = None - self.output_handler = handler - - GLOBAL_REGISTRY = HandlerRegistry( plugins.FormatHandler.match) + self.preferredOutput = None + self.output_handler = handler + + GLOBAL_REGISTRY = HandlerRegistry(plugins.FormatHandler.match) formathandler.FormatHandler.TYPE_REGISTRY = GLOBAL_REGISTRY - - class ArrayDatatype( object ): + + class ArrayDatatype(object): """Mix-in for array datatype classes - + The ArrayDatatype marker essentially is used to mark a particular argument - as having an "array" type, which means that it is eligible for handling + as having an "array" type, which means that it is eligible for handling via the arrays sub-package and its registered handlers. """ + typeConstant = None handler = GLOBAL_REGISTRY getHandler = GLOBAL_REGISTRY.__call__ returnHandler = GLOBAL_REGISTRY.get_output_handler isAccelerated = False + @classmethod - def getRegistry( cls ): + def getRegistry(cls): """Get our handler registry""" - return cls.handler - def from_param( cls, value, typeConstant=None ): + return cls.handler + + def from_param(cls, value, typeConstant=None): """Given a value in a known data-pointer type, convert to a ctypes pointer""" - return cls.getHandler(value).from_param( value, cls.typeConstant ) - from_param = classmethod( logs.logOnFail( from_param, _log ) ) - def dataPointer( cls, value ): + return cls.getHandler(value).from_param(value, cls.typeConstant) + + from_param = classmethod(logs.logOnFail(from_param, _log)) + + def dataPointer(cls, value): """Given a value in a known data-pointer type, return long for pointer""" try: - return cls.getHandler(value).dataPointer( value ) + return cls.getHandler(value).dataPointer(value) except Exception: _log.warning( - """Failure in dataPointer for %s instance %s""", type(value), value, + """Failure in dataPointer for %s instance %s""", + type(value), + value, ) raise - dataPointer = classmethod( logs.logOnFail( dataPointer, _log ) ) - def voidDataPointer( cls, value ): + + dataPointer = classmethod(logs.logOnFail(dataPointer, _log)) + + def voidDataPointer(cls, value): """Given value in a known data-pointer type, return void_p for pointer""" - pointer = cls.dataPointer( value ) + pointer = cls.dataPointer(value) try: return ctypes.c_void_p(pointer) except TypeError: return pointer - voidDataPointer = classmethod( logs.logOnFail( voidDataPointer, _log ) ) - def typedPointer( cls, value ): + + voidDataPointer = classmethod(logs.logOnFail(voidDataPointer, _log)) + + def typedPointer(cls, value): """Return a pointer-to-base-type pointer for given value""" - return ctypes.cast( cls.dataPointer(value), ctypes.POINTER( cls.baseType )) - typedPointer = classmethod( typedPointer ) - def asArray( cls, value, typeCode=None ): + return ctypes.cast(cls.dataPointer(value), ctypes.POINTER(cls.baseType)) + + typedPointer = classmethod(typedPointer) + + def asArray(cls, value, typeCode=None): """Given a value, convert to preferred array representation""" - return cls.getHandler(value).asArray( value, typeCode or cls.typeConstant ) - asArray = classmethod( logs.logOnFail( asArray, _log ) ) - def arrayToGLType( cls, value ): + return cls.getHandler(value).asArray(value, typeCode or cls.typeConstant) + + asArray = classmethod(logs.logOnFail(asArray, _log)) + + def arrayToGLType(cls, value): """Given a data-value, guess the OpenGL type of the corresponding pointer - - Note: this is not currently used in PyOpenGL and may be removed + + Note: this is not currently used in PyOpenGL and may be removed eventually. """ - return cls.getHandler(value).arrayToGLType( value ) - arrayToGLType = classmethod( logs.logOnFail( arrayToGLType, _log ) ) - def arraySize( cls, value, typeCode = None ): + return cls.getHandler(value).arrayToGLType(value) + + arrayToGLType = classmethod(logs.logOnFail(arrayToGLType, _log)) + + def arraySize(cls, value, typeCode=None): """Given a data-value, calculate dimensions for the array (number-of-units)""" - return cls.getHandler(value).arraySize( value, typeCode or cls.typeConstant ) - arraySize = classmethod( logs.logOnFail( arraySize, _log ) ) - def unitSize( cls, value, typeCode=None ): + return cls.getHandler(value).arraySize(value, typeCode or cls.typeConstant) + + arraySize = classmethod(logs.logOnFail(arraySize, _log)) + + def unitSize(cls, value, typeCode=None): """Determine unit size of an array (if possible) - + Uses our local type if defined, otherwise asks the handler to guess... """ - return cls.getHandler(value).unitSize( value, typeCode or cls.typeConstant ) - unitSize = classmethod( logs.logOnFail( unitSize, _log ) ) - def zeros( cls, dims, typeCode=None ): + return cls.getHandler(value).unitSize(value, typeCode or cls.typeConstant) + + unitSize = classmethod(logs.logOnFail(unitSize, _log)) + + def zeros(cls, dims, typeCode=None): """Allocate a return array of the given dimensions filled with zeros""" - return cls.returnHandler().zeros( dims, typeCode or cls.typeConstant ) - zeros = classmethod( logs.logOnFail( zeros, _log ) ) - def dimensions( cls, value ): + return cls.returnHandler().zeros(dims, typeCode or cls.typeConstant) + + zeros = classmethod(logs.logOnFail(zeros, _log)) + + def dimensions(cls, value): """Given a data-value, get the dimensions (assumes full structure info)""" - return cls.getHandler(value).dimensions( value ) - dimensions = classmethod( logs.logOnFail( dimensions, _log ) ) - - def arrayByteCount( cls, value ): + return cls.getHandler(value).dimensions(value) + + dimensions = classmethod(logs.logOnFail(dimensions, _log)) + + def arrayByteCount(cls, value): """Given a data-value, try to determine number of bytes it's final form occupies - + For most data-types this is arraySize() * atomic-unit-size """ - return cls.getHandler(value).arrayByteCount( value ) - arrayByteCount = classmethod( logs.logOnFail( arrayByteCount, _log ) ) - + return cls.getHandler(value).arrayByteCount(value) + + arrayByteCount = classmethod(logs.logOnFail(arrayByteCount, _log)) # the final array data-type classes... - class GLclampdArray( ArrayDatatype, ctypes.POINTER(_types.GLclampd )): + class GLclampdArray(ArrayDatatype, ctypes.POINTER(_types.GLclampd)): """Array datatype for GLclampd types""" + baseType = _types.GLclampd typeConstant = _types.GL_DOUBLE - class GLclampfArray( ArrayDatatype, ctypes.POINTER(_types.GLclampf )): + class GLclampfArray(ArrayDatatype, ctypes.POINTER(_types.GLclampf)): """Array datatype for GLclampf types""" + baseType = _types.GLclampf typeConstant = _types.GL_FLOAT class GLfloat16Array(ArrayDatatype, ctypes.POINTER(_types.GLushort)): """Array datatype for float16 as GLushort types""" + baseType = _types.GLushort typeConstant = _types.GL_HALF_FLOAT - class GLfloatArray( ArrayDatatype, ctypes.POINTER(_types.GLfloat )): + class GLfloatArray(ArrayDatatype, ctypes.POINTER(_types.GLfloat)): """Array datatype for GLfloat types""" + baseType = _types.GLfloat typeConstant = _types.GL_FLOAT - class GLdoubleArray( ArrayDatatype, ctypes.POINTER(_types.GLdouble )): + class GLdoubleArray(ArrayDatatype, ctypes.POINTER(_types.GLdouble)): """Array datatype for GLdouble types""" + baseType = _types.GLdouble typeConstant = _types.GL_DOUBLE - class GLbyteArray( ArrayDatatype, ctypes.POINTER(_types.GLbyte )): + class GLbyteArray(ArrayDatatype, ctypes.POINTER(_types.GLbyte)): """Array datatype for GLbyte types""" + baseType = _types.GLbyte typeConstant = _types.GL_BYTE - class GLcharArray( ArrayDatatype, ctypes.c_char_p): + class GLcharArray(ArrayDatatype, ctypes.c_char_p): """Array datatype for ARB extension pointers-to-arrays""" + baseType = _types.GLchar typeConstant = _types.GL_BYTE + GLcharARBArray = GLcharArray - class GLshortArray( ArrayDatatype, ctypes.POINTER(_types.GLshort )): + class GLshortArray(ArrayDatatype, ctypes.POINTER(_types.GLshort)): """Array datatype for GLshort types""" + baseType = _types.GLshort typeConstant = _types.GL_SHORT - class GLintArray( ArrayDatatype, ctypes.POINTER(_types.GLint )): + class GLintArray(ArrayDatatype, ctypes.POINTER(_types.GLint)): """Array datatype for GLint types""" + baseType = _types.GLint typeConstant = _types.GL_INT - class GLubyteArray( ArrayDatatype, ctypes.POINTER(_types.GLubyte )): + class GLubyteArray(ArrayDatatype, ctypes.POINTER(_types.GLubyte)): """Array datatype for GLubyte types""" + baseType = _types.GLubyte typeConstant = _types.GL_UNSIGNED_BYTE + GLbooleanArray = GLubyteArray - class GLushortArray( ArrayDatatype, ctypes.POINTER(_types.GLushort )): + class GLushortArray(ArrayDatatype, ctypes.POINTER(_types.GLushort)): """Array datatype for GLushort types""" + baseType = _types.GLushort typeConstant = _types.GL_UNSIGNED_SHORT - class GLuintArray( ArrayDatatype, ctypes.POINTER(_types.GLuint )): + class GLuintArray(ArrayDatatype, ctypes.POINTER(_types.GLuint)): """Array datatype for GLuint types""" + baseType = _types.GLuint typeConstant = _types.GL_UNSIGNED_INT - - class GLint64Array( ArrayDatatype, ctypes.POINTER(_types.GLint64 )): + + class GLint64Array(ArrayDatatype, ctypes.POINTER(_types.GLint64)): """Array datatype for GLuint types""" + baseType = _types.GLint64 - typeConstant = None # TODO: find out what this should be! - - class GLuint64Array( ArrayDatatype, ctypes.POINTER(_types.GLuint64 )): + typeConstant = None # TODO: find out what this should be! + + class GLuint64Array(ArrayDatatype, ctypes.POINTER(_types.GLuint64)): """Array datatype for GLuint types""" + baseType = _types.GLuint64 typeConstant = _types.GL_UNSIGNED_INT64 - class GLenumArray( ArrayDatatype, ctypes.POINTER(_types.GLenum )): + class GLenumArray(ArrayDatatype, ctypes.POINTER(_types.GLenum)): """Array datatype for GLenum types""" + baseType = _types.GLenum typeConstant = _types.GL_UNSIGNED_INT - class GLsizeiArray( ArrayDatatype, ctypes.POINTER(_types.GLsizei )): + + class GLsizeiArray(ArrayDatatype, ctypes.POINTER(_types.GLsizei)): """Array datatype for GLsizei types""" + baseType = _types.GLsizei typeConstant = _types.GL_INT - class GLvoidpArray( ArrayDatatype, ctypes.POINTER(_types.GLvoid )): + + class GLvoidpArray(ArrayDatatype, ctypes.POINTER(_types.GLvoid)): """Array datatype for GLenum types""" + baseType = _types.GLvoidp typeConstant = _types.GL_VOID_P - + class GLfixedArray(ArrayDatatype, ctypes.POINTER(_types.GLfixed)): - baseType = _types.GLfixed + baseType = _types.GLfixed typeConstant = _types.GL_FIXED - + else: # Cython-coded array handler - _log.info( 'Using accelerated ArrayDatatype' ) - ArrayDatatype = ADT( None, None ) - GLclampdArray = ADT( GL_1_1.GL_DOUBLE, _types.GLclampd ) - GLclampfArray = ADT( GL_1_1.GL_FLOAT, _types.GLclampf ) - GLdoubleArray = ADT( GL_1_1.GL_DOUBLE, _types.GLdouble ) - GLfloat16Array = ADT( GL_1_1.GL_HALF_FLOAT, _types.GLushort ) - GLfloatArray = ADT( GL_1_1.GL_FLOAT, _types.GLfloat ) - GLbyteArray = ADT( GL_1_1.GL_BYTE, _types.GLbyte ) - GLcharArray = GLcharARBArray = ADT( GL_1_1.GL_BYTE, _types.GLchar ) - GLshortArray = ADT( GL_1_1.GL_SHORT, _types.GLshort ) - GLintArray = ADT( GL_1_1.GL_INT, _types.GLint ) - GLubyteArray = GLbooleanArray = ADT( GL_1_1.GL_UNSIGNED_BYTE, _types.GLubyte ) - GLushortArray = ADT( GL_1_1.GL_UNSIGNED_SHORT, _types.GLushort ) - GLuintArray = ADT( GL_1_1.GL_UNSIGNED_INT, _types.GLuint ) - GLint64Array = ADT( None, _types.GLint64 ) - GLuint64Array = ADT( GL_1_1.GL_UNSIGNED_INT64, _types.GLuint64 ) - GLenumArray = ADT( GL_1_1.GL_UNSIGNED_INT, _types.GLenum ) - GLsizeiArray = ADT( GL_1_1.GL_INT, _types.GLsizei ) - GLvoidpArray = ADT( _types.GL_VOID_P, _types.GLvoidp ) - GLfixedArray = ADT( _types.GL_FIXED, _types.GLfixed ) + _log.debug("Using accelerated ArrayDatatype") + ArrayDatatype = ADT(None, None) + GLclampdArray = ADT(GL_1_1.GL_DOUBLE, _types.GLclampd) + GLclampfArray = ADT(GL_1_1.GL_FLOAT, _types.GLclampf) + GLdoubleArray = ADT(GL_1_1.GL_DOUBLE, _types.GLdouble) + GLfloat16Array = ADT(GL_1_1.GL_HALF_FLOAT, _types.GLushort) + GLfloatArray = ADT(GL_1_1.GL_FLOAT, _types.GLfloat) + GLbyteArray = ADT(GL_1_1.GL_BYTE, _types.GLbyte) + GLcharArray = GLcharARBArray = ADT(GL_1_1.GL_BYTE, _types.GLchar) + GLshortArray = ADT(GL_1_1.GL_SHORT, _types.GLshort) + GLintArray = ADT(GL_1_1.GL_INT, _types.GLint) + GLubyteArray = GLbooleanArray = ADT(GL_1_1.GL_UNSIGNED_BYTE, _types.GLubyte) + GLushortArray = ADT(GL_1_1.GL_UNSIGNED_SHORT, _types.GLushort) + GLuintArray = ADT(GL_1_1.GL_UNSIGNED_INT, _types.GLuint) + GLint64Array = ADT(None, _types.GLint64) + GLuint64Array = ADT(GL_1_1.GL_UNSIGNED_INT64, _types.GLuint64) + GLenumArray = ADT(GL_1_1.GL_UNSIGNED_INT, _types.GLenum) + GLsizeiArray = ADT(GL_1_1.GL_INT, _types.GLsizei) + GLvoidpArray = ADT(_types.GL_VOID_P, _types.GLvoidp) + GLfixedArray = ADT(_types.GL_FIXED, _types.GLfixed) EGLAttribArray = GLintArray GL_CONSTANT_TO_ARRAY_TYPE = { - GL_1_1.GL_HALF_FLOAT : GLfloat16Array, - GL_1_1.GL_DOUBLE : GLclampdArray, - GL_1_1.GL_FLOAT : GLclampfArray, - GL_1_1.GL_FLOAT : GLfloatArray, - GL_1_1.GL_DOUBLE : GLdoubleArray, - GL_1_1.GL_BYTE : GLbyteArray, - GL_1_1.GL_SHORT : GLshortArray, - GL_1_1.GL_INT : GLintArray, - GL_1_1.GL_UNSIGNED_BYTE : GLubyteArray, - GL_1_1.GL_UNSIGNED_SHORT : GLushortArray, - GL_1_1.GL_UNSIGNED_INT : GLuintArray, - _types.GL_FIXED: GLfixedArray, - #GL_1_1.GL_UNSIGNED_INT : GLenumArray, + GL_1_1.GL_HALF_FLOAT: GLfloat16Array, + GL_1_1.GL_DOUBLE: GLclampdArray, + GL_1_1.GL_FLOAT: GLclampfArray, + GL_1_1.GL_FLOAT: GLfloatArray, + GL_1_1.GL_DOUBLE: GLdoubleArray, + GL_1_1.GL_BYTE: GLbyteArray, + GL_1_1.GL_SHORT: GLshortArray, + GL_1_1.GL_INT: GLintArray, + GL_1_1.GL_UNSIGNED_BYTE: GLubyteArray, + GL_1_1.GL_UNSIGNED_SHORT: GLushortArray, + GL_1_1.GL_UNSIGNED_INT: GLuintArray, + _types.GL_FIXED: GLfixedArray, + # GL_1_1.GL_UNSIGNED_INT : GLenumArray, }