PyVRML97 2.3.4b3__py3-none-any.whl

pyvrml97-2.3.4b3.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: PyVRML97
+Version: 2.3.4b3
+Summary: VRML97 Scenegraph model for Python
+Author-email: "Mike C. Fletcher" <mcfletch@vrplumber.com>
+License: BSD-style, see license.txt for details
+Project-URL: Homepage, http://pyopengl.sourceforge.net/context/
+Keywords: VRML,VRML97,scenegraph
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: C
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+Requires-Dist: numpy
+Requires-Dist: PyDispatcher
+Requires-Dist: simpleparse
+
+PyVRML97 Scenegraph Model
+==========================
+
+PyVRML97 is the scenegraph model from `OpenGLContext`_ but can be used separately
+in VRML97 processing tools. It relies on `SimpleParse`_, `PyDispatcher`_ and `Numpy`_
+to provide the basic modelling functionality.
+
+Properties (fields) in PyVRML97 follow the "Observer" pattern, and PyVRML97 
+provides a cache mechanism that allows you to do cache invalidation when 
+setting properties (fields). OpenGLContext uses that extensively to 
+optimize the rendering process.
+
+.. _`OpenGLContext`: https://pypi.python.org/pypi/OpenGLContext
+.. _`SimpleParse`: https://pypi.python.org/pypi/SimpleParse
+.. _`PyDispatcher`: https://pypi.python.org/pypi/PyDispatcher
+.. _`Numpy`: https://pypi.python.org/pypi/numpy
+
+Installation
+-------------
+
+It isn't common to directly install PyVRML97 itself (normally you want to 
+install it as part of installing OpenGLContext), but should you wish to, you
+can install via::
+
+    $ pip install PyVRML97 PyVRML97_accelerate
+
+The PyVRML97_accelerate module requires that you have a working compiler
+(or, if you are on Windows, prebuilt wheels likely are available).
+
+.. image:: https://ci.appveyor.com/api/projects/status/MikeCFletcher/pyvrml97/branch/master
+    :target: https://ci.appveyor.com/project/MikeCFletcher/pyvrml97
+    :alt: Appveyor Build
+
+.. image:: https://img.shields.io/pypi/v/pyvrml97.svg
+    :target: https://pypi.python.org/pypi/pyvrml97
+    :alt: Latest PyPI Version
+
+.. image:: https://img.shields.io/pypi/dm/pyvrml97.svg
+    :target: https://pypi.python.org/pypi/pyvrml97
+    :alt: Monthly download counter
+
+Build/Release Process 
+----------------------
+
+* Push an annotated tag with `version` prefix (github workflow `build_and_publish.yml`)

pyvrml97-2.3.4b3.dist-info/RECORD

@@ -0,0 +1,39 @@
+vrml/__init__.py,sha256=MaK51RM3d-jCwGlHh5Emvb_QVwejMvHdhViz5DgWGRc,827
+vrml/_bytes.py,sha256=Xug9wGWIn91Y9HeTDuZwxhsSxgUYAmNFH9U409JvShY,2404
+vrml/arrays.py,sha256=b8MvRaTJ8dJRTk3oQ_WhHlEMU7urbO4D0vqftb8lEZo,2511
+vrml/cache.py,sha256=netNmLNUVSutC2beD0Z89I_wOv7stIUGbzSS0PUyzVU,8062
+vrml/copier.py,sha256=1tP1xbHe5UOulpnzO_ccywHfm0HoQTSb-l-o17FgPqE,1077
+vrml/csscolors.py,sha256=d76-sTGbLcMZs9Wh65cmLrdf2VcKsQrwHYOiqat2ztA,6978
+vrml/event.py,sha256=6u_Je6Qad8nauBc2vCyOvEBJzv-4ZseuXn1yOse5Dtg,845
+vrml/field.py,sha256=9c5aC_ixOTSkkaowpHPocf93ukZ60maZXtXg_LZQDT4,14380
+vrml/fieldtypes.py,sha256=sTchoCoi8elYOXPNlka9i1oEfQnjqjUfBPgYfz3ZkYo,37090
+vrml/node.py,sha256=JfE8xg14ptkFBgq3WkuEf6IRpEsDbxTuxLiTNh4IxRM,18364
+vrml/nodepath.py,sha256=ojvV5Wg3ktZ0s82HGwJatuvhFOWDPmlZfpk36qEXxOQ,2388
+vrml/olist.py,sha256=asZ3Z_AE_5wiAi0yQJX-RCaentaqffUp1IcuqR_hMIs,4774
+vrml/protofunctions.py,sha256=Any0tervT96fWFPt9q9fELbus5yoqX1LW2Iq95QIznM,6685
+vrml/protonamespace.py,sha256=WkWoZykw09OIxi7DjGiwXdSYFExDBNLLAeyk_lX1ocY,567
+vrml/route.py,sha256=KSx9vYtYRW63_hjS6wrxus4e5BZf6CDM5PDGFpbk5lM,6139
+vrml/weakkeydictfix.py,sha256=O-svMXnT2I7333EKtJOp59Kxj_QLaoAHzJGwfh2APmQ,1278
+vrml/weaklist.py,sha256=36WRCeWWyPsMbfoSjEBUxlQIQxSNjP2EqVbMMXVuQTs,5759
+vrml/weaktuple.py,sha256=bxIA6QZxIiWa1PEy1TNEDlRsGbSwL9gp7UJcgOKZ2BE,4733
+vrml/vrml200x/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vrml/vrml200x/parser.py,sha256=deDLgwLdXCBWudmhuFxU2eY_yyYhEOv_gg4ECwIis_k,3842
+vrml/vrml97/__init__.py,sha256=QZ1php9-9TKWFblZ8L6LctbKTFJSKOVQtqM1JQHScqs,119
+vrml/vrml97/_transformmatrix.py,sha256=rBG6B7mi32cGA3BzilzFfUoJklmUVU4-IXucOrPE2tg,3986
+vrml/vrml97/_transformmatrix_accel.py,sha256=AMh9R0lMrXdEtsa3r9iaHDgtcyP0n4mq7mRAUtgmYlM,1922
+vrml/vrml97/basenamespaces.py,sha256=BRk0qAG7kAWBvXLEVOEz0eSgWoq50JMYNLOb9AvM1-8,740
+vrml/vrml97/basenodes.py,sha256=IXNxZq7EuoXRLA_DhZ9XLRt2e_0gAgmQtQabdydsZzY,28273
+vrml/vrml97/linearise.py,sha256=p9a9vo05RmTgZnJSQKml42tnPxPHRrfLca5Olngy7vs,21946
+vrml/vrml97/nodepath.py,sha256=dPtrTpYGrRKdjc0rQy1CIRW1rKYYs6-8LP78ne5OtcI,4948
+vrml/vrml97/nodetypes.py,sha256=V00a3zA5ucNGn-csVNQL6f-hfSjUG6DVbREaiQzYYRQ,2275
+vrml/vrml97/nurbs.py,sha256=JTRZBSEWOwvfL34tmgbk2THLErVpKlLZuH4-Su6dqUQ,3500
+vrml/vrml97/parseprocessor.py,sha256=ZeTIhPqbxmpNy_mWfEIHud3cGom1blNoIPH2yITVHyU,16070
+vrml/vrml97/parser.py,sha256=3jsCmpiYpO846QuQJJikUlGJeKAo-OxBxCmqjVYh5AA,3350
+vrml/vrml97/scenegraph.py,sha256=8ebIqPWsiwVBAQrncuOfh1VbLGbIvWVAsnoCiBeVmLc,6955
+vrml/vrml97/script.py,sha256=cxXRJp9xbYJTlO-hLqXSR_-UBmc8BWHSJE0_4Hor3_U,809
+vrml/vrml97/shaders.py,sha256=Igc8A1td7n9pNl5-QINA1X-ZEKPYVcec-djleJhDYg4,5421
+vrml/vrml97/transformmatrix.py,sha256=-7Em6LRpNxErUKqGOFoTPLma04oCrbdel2eJdDYeGjo,5673
+pyvrml97-2.3.4b3.dist-info/METADATA,sha256=Ue-K5TWkQR5onszMzFXx8_Ezclo7-GsYlqeThvKLfIs,2491
+pyvrml97-2.3.4b3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyvrml97-2.3.4b3.dist-info/top_level.txt,sha256=HNkQ-TkhfmnJgOd_zwLjqNi-T86T_CSpBac8zWIFGBc,5
+pyvrml97-2.3.4b3.dist-info/RECORD,,

pyvrml97-2.3.4b3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyvrml97-2.3.4b3.dist-info/top_level.txt

@@ -0,0 +1 @@
+vrml

vrml/__init__.py

@@ -0,0 +1,22 @@
+"""VRML Directed Acyclic Graph library and VRML97 tools
+
+This package is a partial representation of VRML97
+node and prototype semantics based loosely on the
+original mcf.vrml processing engine by the author.
+It is strongly dependent on the Python 2.2.2 property
+class, and as such will not likely be portable to
+earlier python versions.
+
+The package includes a full VRML97 parser and
+lineariser based on the SimpleParse 2.0 parsing engine
+(also by the author).
+
+The vrml.vrml97 sub-package contains classes and
+functions specifically relating to the VRML97 ISO
+standard.  For instance, the vrml.vrml97.basenodes
+file contains the "prototypes" for most of the
+built-in nodes in the official specification.
+"""
+__version__ = "2.3.4b3"
+__author__ = "Michael Colin Fletcher"
+__license__ = "BSD-style, see license.txt for details"

vrml/_bytes.py

@@ -0,0 +1,85 @@
+"""8-bit string definitions for Python 2/3 compatibility
+
+Defines the following which allow for dealing with Python 3 breakages:
+
+    STR_IS_BYTES
+    STR_IS_UNICODE
+    
+        Easily checked booleans for type identities
+    
+    _NULL_8_BYTE
+    
+        An 8-bit byte with NULL (0) value 
+    
+    as_8_bit( x, encoding='utf-8')
+    
+        Returns the value as the 8-bit version
+    
+    unicode -- always pointing to the unicode type 
+    bytes -- always pointing to the 8-bit bytes type
+"""
+import sys
+
+_NULL_8_BYTE = b'\000'
+try:
+    STR_IS_BYTES = True
+    STR_IS_UNICODE = False
+    unicode 
+    bytes = str
+    unicode = unicode
+    long = long
+    integer_types = int,long
+    def as_8_bit( x, encoding='utf-8' ):
+        if isinstance( x, unicode ):
+            return x.encode( encoding )
+        return bytes( x )
+    def as_str( x, encoding='utf-8'):
+        """Produce a native string (i.e. different on python 2 and 3)"""
+        if isinstance(x,bytes):
+            return x
+        elif isinstance(x,unicode):
+            return x.encode(encoding)
+        else:
+            return str(x)
+except NameError:
+    STR_IS_BYTES = False
+    STR_IS_UNICODE = True
+    unicode = str
+    bytes = bytes
+    long = int
+    integer_types = int,
+    def as_8_bit( x, encoding='utf-8' ):
+        if isinstance( x,unicode ):
+            return x.encode(encoding)
+        elif isinstance( x, bytes ):
+            # Note: this can create an 8-bit string that is *not* in encoding,
+            # but that is potentially exactly what we wanted, as these can 
+            # be arbitrary byte-streams being passed to C functions
+            return x
+        return str(x).encode( encoding )    
+    def as_str( x, encoding='utf-8'):
+        """Produce a native string (i.e. different on python 2 and 3)"""
+        if isinstance(x,unicode):
+            return x
+        elif isinstance(x,bytes):
+            return x.decode(encoding)
+        else:
+            return str(x)
+
+if hasattr( sys, 'maxsize' ):
+    maxsize = sys.maxsize 
+else:
+    maxsize = sys.maxint
+
+def as_unicode(x,encoding='utf-8'):
+    """Ensure is a unicode object given default encoding"""
+    if isinstance(x,unicode):
+        return x
+    elif isinstance(x,bytes):
+        try:
+            return x.decode(encoding)
+        except UnicodeDecodeError as err:
+            return x.decode('latin-1')
+    else:
+        return unicode(x)
+

vrml/arrays.py

@@ -0,0 +1,86 @@
+"""Abstraction point allowing use with numpy or Numeric
+
+Chooses numpy if available because when it's installed
+Numeric tends to be a bit flaky...
+"""
+
+from numpy import *
+
+try:
+    # TODO: don't import this here, as it's not
+    # actually *used* in pyvrml97, it's just used
+    # in OpenGLContext...
+    from vrml_accelerate import frustcullaccel
+except ImportError as err:
+    frustcullaccel = None
+# why did this get taken out?  Is divide now safe?
+amin = amin
+amax = amax
+divide_safe = divide
+# Now deal with differing numpy APIs...
+a = array([1, 2, 3], 'i')
+ArrayType = ndarray  # alias removed in later versions
+# Take's API changed from Numeric, we've updated to
+# always provide axis now...
+if hasattr(a, '__array_typestr__'):
+
+    def typeCode(a):
+        """Retrieve the typecode for the given array
+
+        Depending on whether you access the classic or new API
+        you have different access methods, so we have to use
+        the typecode() method if __array_typestr__ isn't there.
+        """
+        try:
+            return a.__array_typestr__
+        except AttributeError:
+            return a.typecode()
+
+else:
+
+    def typeCode(a):
+        """Retrieve the typecode for the given array
+
+        Depending on whether you access the classic or new API
+        you have different access methods, so we have to use
+        the typecode() method if .dtype.char isn't there.
+        """
+        try:
+            return a.dtype.char
+        except AttributeError:
+            return a.typecode()
+
+
+del a
+implementation_name = 'numpy'
+try:
+    # PyVRML97 is from before numpy printed errors, we explicitly do not care
+    # about the divide-by-zero, which commonly happens in mesh data processing
+    # TODO: likely should rework the mesh processing to check manually and remove
+    # this sledge-hammer approach
+    seterr(all='ignore')
+except Exception as err:
+    pass
+
+
+def safeCompare(first, second):
+    """Watch out for pointless numpy truth-value checks"""
+    if first is None:
+        if second is None:
+            return True
+        else:
+            return False
+    elif second is None:
+        return False
+    if isinstance(first, (int, float, str)):
+        return first == second
+    if isinstance(first, ArrayType) and isinstance(second, ArrayType):
+        return bool(any(first == second))
+    elif type(first) != type(second):
+        return False
+    return bool(first == second)
+
+
+def contiguous(a):
+    """Force to a contiguous array"""
+    return array(a, typeCode(a))

vrml/cache.py

@@ -0,0 +1,250 @@
+"""Caching mechanism for scene graph
+
+Basically, the scenegraph Cache allows you to associate
+data with particular nodes in the scene graph without
+actually attaching the information to the particular
+node being annotated.
+
+This allows us to store cached information such as:
+    display list objects
+    texture objects
+    compiled array geometry
+
+The cache uses weak reference key dictionaries to clear
+the cache of data associated with deleted nodes within
+the scene graph.  similarly, cache is cleared when node
+fields which are dependencies of the cache are changed.
+
+The cache is based on the vrml.field and dispatch.dispatcher
+modules.  All field objects by default provide dispatcher
+notifications on set and delete, and can provide
+notification on get as well.  The cache watches for these
+notifications for dependent nodes where the dispatcher
+messages are (type, fieldObject) for type in ("set","del").
+
+There is a per-context cache, and a global cache, display-
+lists, textures, etceteras should be stored in the per-
+context cache, while data with dependencies only on the
+node can be stored in the global cache.
+
+Note:
+    The cache makes extensive use of weak references, and
+    was the failure case which exposed a number of problems
+    with the Python 2.2.2 weakref and weakkeydictionary
+    mechanisms.
+"""
+from vrml import protofunctions
+import weakref
+#from vrml.weakkeydictfix import WeakKeyDictionary
+from pydispatch import dispatcher
+import traceback
+
+import sys
+if sys.version_info[0] == 2:
+    bytes = str 
+else:
+    unicode = str
+
+class Cache (dict):
+    """Trivial sub-class of a dict which has some convenience methods
+
+    Maps id(client): {
+        key="": CacheHolder()
+    }
+
+    That is, for each client node, a dictionary
+    holds opaque key(normally strings) to CacheHolder
+    instances.  The CacheHolder is responsible for
+    most of the implementation of the cache.
+    """
+    def getHolder( self, client, key = ""):
+        """Return the cache holder for the given client and key"""
+        current = self.get(id(client))
+        if current is not None:
+            return current.get( key)
+        return None
+    def getData( self, client, key="", default=None):
+        """Return the data for given client and key, default otherwise"""
+        current = self.get( id(client) )
+        if current is not None:
+            current = current.get( key )
+            if current is not None:
+                return current.data
+        return default
+    def holder(
+        self, 
+        client,
+        data,
+        key="",
+    ):
+        """Create a new CacheHolder in this cache"""
+        return CacheHolder(
+            client,
+            data,
+            key,
+            self,
+        )
+
+CACHE = Cache()
+getData = CACHE.getData
+
+def cleaner( cache, id ):
+    """Return callback function that cleans the given id from cache"""
+    def clean_id( weak ):
+        try:
+            del cache[id]
+        except Exception:
+            pass 
+    return clean_id
+
+
+class CacheHolder( object ):
+    """Holder for data values within a cache
+
+    The CacheHolder provides the bulk of the cache
+    implementation.  It associates an opaque data value
+    with a client node and an opaque key.  The key
+    value allows multiple dimensions of storage, to
+    allow, for instance storing compiled shadow
+    information separate from compiled geometry
+    information.
+
+    The depend method uses the dispatcher module
+    to invalidate this CacheHolder when the given
+    fields for the given nodes are changed.
+
+    Attributes:
+        client -- weak reference to the client node
+        key -- strong reference to the opaque key value
+        data -- strong reference to the opaque data value
+        cache -- weak reference to the cache in which
+            we are storing ourselves
+    """
+    #__slots__ = ('client','data','key','cache','nodeDependencies','__weakref__','notifier')
+    def __init__(
+        self,
+        client, data,
+        key="",
+        cache = CACHE,
+    ):
+        """Initialise the cache-deletion callable
+        
+        client -- the node doing the caching, if gc'd,
+            then the entire cache for the node is deleted
+        key -- opaque key into the cache's per-node storage
+        cache -- the particular cache in which to store
+            ourselves.
+        """
+        client_id = id(client)
+        self.client = weakref.ref(client, cleaner( cache,client_id) )
+        self.key = key
+        self.data = data
+        self.cache = weakref.ref( cache )
+        self.nodeDependencies = []
+
+        # get the cached values for this client node
+        set = cache.get(client_id, None)
+        if set is None:
+            cache[ client_id ] = set = {}
+        set[key] = self
+    def set( self, data ):
+        """Set data after instantiation"""
+        self.data = data
+    
+    def depend( self, node, field=None ):
+        """Add a dependency on given node's field value
+
+        source -- the node being watched
+        field -- the field on the node being watched
+
+        Dependency on the node means that this cache
+        holder will be invalidated if the field value
+        changes.  This does not create a dependency
+        on the existence of node, so you should set
+        the dependency for the field holding any
+        nodes which should invalidate this CacheHolder
+
+        Note:
+            This does not affect any other CacheHolder
+            for our client node.
+        """
+        if field is not None:
+            if isinstance( field, (bytes,unicode)):
+                field = protofunctions.getField(node, field)
+            self.depend_signal(
+                ('set', field),#signal
+                node, # sender
+            )
+            self.depend_signal(
+                ('del', field),#signal
+                node, # sender
+            )
+            self.depend_signal(
+                ('route', field),#signal
+                node, # sender
+            )
+        else:
+            # dependency on the mere existence of the node
+            self.depend_object( node )
+    def depend_signal( self, signal, sender=dispatcher.Any ):
+        """Depend on signal from sender"""
+        dispatcher.connect(
+            self.clear,#receiver
+            signal,
+            sender,
+        )
+    def depend_object( self, node ):
+        """Depend on node's existence"""
+        self.nodeDependencies.append(
+            weakref.ref(
+                node,
+                self,
+            )
+        )
+    def clear( self, signal=None, sender=None ):
+        """Clear this object's held value (only)"""
+        if not self.client():
+            self( signal=signal, sender=sender )
+        else:
+            self.data = None 
+    def __call__( self, signal=None, sender=None ):
+        """Delete the cached value (this object)
+
+        This de-registers ourselves from our cache object,
+        with suitable checks for whether our cache is still
+        alive itself, and whether it still has an entry
+        for our client and our key.
+
+        If this is the last registered cache object
+        for our client, deletes the overall cache dictionary
+        for the client.
+        """
+        try:
+            cache = self.cache()
+            if cache is None:
+                return 0
+            client = self.client()
+            if client is None:
+                return 0
+            client_id = id(client)
+            current = cache.get( client_id )
+            self.data = None
+            if current is None:
+                return 0
+            try:
+                del current[ self.key ]
+                if not current:
+                    try:
+                        del cache[ client_id ]
+                    except KeyError:
+                        pass
+                try:
+                    del self.nodeDependencies[:]
+                except:
+                    pass
+                return 1
+            except KeyError:
+                return 0
+        except RuntimeError:
+            traceback.print_exc()
+            

vrml/copier.py

@@ -0,0 +1,27 @@
+"""Object representing node-copying pass"""
+
+class Copier( object ):
+    """An object representing a node-copying pass"""
+    def __init__(
+        self,
+        shareProtos = 1,
+        instantiation=0,
+    ):
+        """Instantiate the copier object
+
+        # share prototypes, we don't currently support not doing this!
+        shareProtos -- whether to try to share prototypes between source
+            and copied nodes
+        instantiation -- whether this is a prototype-instantiation copy
+        baseNode -- baseNode for prototype instantiations, this is the
+            node whose sub-scenegraph is being built by the copier
+        """
+        self.shareProtos, self.instantiation = shareProtos, instantiation
+    def use( self, clientNode, newNode=None ):
+        """See whether (or register that) we have a USE for this (source) clientNode"""
+        if not hasattr( self, 'useNodes'):
+            self.useNodes = {}
+        if newNode is not None:
+            self.useNodes[ clientNode ] = newNode
+        else:
+            return self.useNodes.get( clientNode )