PyVRML97 2.3.4b3__py3-none-any.whl

vrml/olist.py

@@ -0,0 +1,126 @@
+"""Observable list class"""
+from pydispatch.dispatcher import send
+import weakref, types
+try:
+    set 
+except NameError as err:
+    from sets import Set as set
+
+class OList( list ):
+    """List sub-class which generates pydispatch events on changes
+    
+    Generates 4 types of events:
+    
+        * NEW_CHILD_EVT, from self, with value=child, for each added child
+        * NEW_PARENT_EVT, from child, with parent=self, for each added child 
+        * DEL_CHILD_EVT, from self, with value=child, for each removed child 
+        * DEL_PARENT_EVT, from child, with parent=self, for each removed child
+        
+    Note that the OList semantics are a little loose currently, as 
+    it sometimes acts as though adding a new duplicate child is not 
+    an event and sometimes acts as though it is.  This doesn't cause 
+    problems for the OpenGLContext scenegraph.
+    
+    The OList is intended for situations where slow-write-fast-read 
+    is the primary requirement, it allows you to hook writing events 
+    in order to recalculate/cache values.
+    """
+    NEW_CHILD_EVT = 'new'
+    NEW_PARENT_EVT = 'added'
+    DEL_CHILD_EVT = 'del'
+    DEL_PARENT_EVT = 'removed'
+    sender = None
+    extraArgs = None
+    def setSender( self, sender, **named ):
+        """Set the (node) from which messages should be sent"""
+        if sender is not None:
+            sender = weakref.ref(sender)
+        self.sender = sender
+        self.extraArgs = named
+    def _sender( self ):
+        sender = self
+        if self.sender is not None:
+            sender = self.sender()
+            if sender is None:
+                sender = self
+        return sender
+    def _sendAdded( self, value ):
+        """Send events for adding value to self"""
+        sender = self._sender()
+        send( self.NEW_CHILD_EVT, sender, value=value, **(self.extraArgs or {}))
+        send( self.NEW_PARENT_EVT, value, parent=sender,**(self.extraArgs or {}))
+    def _sendRemoved( self, value ):
+        """Send events for removing value from self"""
+        sender = self._sender()
+        send( self.DEL_CHILD_EVT, sender, value=value,**(self.extraArgs or {}))
+        send( self.DEL_PARENT_EVT, value, parent=sender,**(self.extraArgs or {}))
+    
+    def append( self, value ):
+        """Append a value and send a message"""
+        super( OList,self ).append( value )
+        self._sendAdded( value )
+        return value 
+    def insert( self, index, value ):
+        """Insert a new item at index"""
+        super( OList,self ).insert( index, value )
+        self._sendAdded( value )
+        return value 
+    def pop( self, index=None ):
+        """Pop a single item out of the list"""
+        if index is None:
+            index = len(self)-1
+        value = super( OList,self ).pop( index )
+        self._sendRemoved( value )
+        return value
+    def remove( self, item ):
+        """Remove this instance from the list"""
+        super(OList,self).remove( item )
+        self._sendRemoved( item )
+        return item
+    def __delitem__( self, index ):
+        """Delete a single item"""
+        if isinstance( index, slice ):
+            current = self.__getitem__( index )
+            for value in current:
+                self._sendRemoved( value )
+            super( OList,self ).__delitem__( index )
+            return current 
+        else:
+            value = self[index]
+            self._sendRemoved( value )
+        return value
+    def __delslice__( self, i,j):
+        return self.__delitem__( slice(i,j))
+    def __setitem__( self, index, value ):
+        """Set a value and send a message"""
+        if isinstance( index, slice ):
+            values = list(value)
+            previous = self.__getitem__( index )
+            currents = set( previous )
+            super(OList,self).__setitem__( index, values )
+            for value in values:
+                if value not in currents:
+                    self._sendAdded( value )
+                else:
+                    try:
+                        previous.remove( value )
+                    except ValueError as err:
+                        pass
+            for current in previous:
+                self._sendRemoved( current )
+            return values 
+        else:
+            current = self[index]
+            if current is not value:
+                self._sendRemoved( current )
+            super( OList,self ).__setitem__( index, value )
+            if current is not value:
+                self._sendAdded( value )
+            return value 
+    def __setslice__( self, i,j, iterable ):
+        return self.__setitem__( slice(i,j), iterable)
+    def __iadd__( self, iterable ):
+        """Do an in-place add"""
+        return self.__setitem__( slice(len(self),len(self)), iterable )
+    extend = __iadd__
+    

vrml/protofunctions.py

@@ -0,0 +1,233 @@
+"""Functions for manipulating prototypes (node classes)
+
+Prototypes are implemented as classes, and so are
+available from every instance node, but we often
+want to be able to manipulate the classes themselves
+without needing lots of class-methods
+
+The protofunctions module allows us to abstract the
+actual implementation of the prototype away.  If we
+at some point want to create a real "prototype" class,
+we could do so with most changes confined to this
+module.
+"""
+
+from __future__ import unicode_literals
+
+
+def _getcls(cls):
+    """Utility function returns class when passed instance or class"""
+    if type(cls) == type:
+        return cls
+    else:
+        return cls.__class__
+
+
+def getPrototype(cls):
+    """Return the prototype for the node or class
+    returns either the argument (if it is a proto)
+    or the prototype of the argument
+    """
+    return _getcls(cls)
+
+
+def protoName(obj, value=None, *args, **named):
+    """Get/set the prototype name for the object"""
+    obj = _getcls(obj)
+    if value is not None:
+        return setattr(obj, "PROTO", value)
+    elif issubclass(obj, list):
+        return '__MFNode__'
+    else:
+        possible = getattr(obj, "PROTO")
+        if not possible:
+            return obj.__name__.split(".")[-1]
+        return possible
+
+
+def defName(obj, value=None, *args, **named):
+    """Get/set the VRML97 defName for the object"""
+    from vrml import node
+
+    if value is not None:
+        return node.Node.DEF.fset(obj, value, *args, **named)
+    else:
+        return node.Node.DEF.fget(obj, *args, **named)
+
+
+def name(obj, value=None, *args, **named):
+    """Get/set prototype name for prototypes, DEF name for nodes"""
+    if type(obj) == type:
+        return protoName(obj, value, *args, **named)
+    else:
+        return defName(obj, value, *args, **named)
+
+
+def root(obj, value=None, *args, **named):
+    """Get/set root-node reference for nodes/protos"""
+    from vrml import node
+
+    if value is not None:
+        return node.Node.rootSceneGraph.fset(obj, value, *args, **named)
+    else:
+        return node.Node.rootSceneGraph.fget(obj, *args, **named)
+
+
+def builtin(cls):
+    """Return whether the class is "built-in" to the system"""
+    from vrml import node
+
+    return not issubclass(_getcls(cls), node.PrototypedNode)
+
+
+def addField(cls, field):
+    """Add a particular field/event to the class/prototype definition
+
+    At present this just calls setattr(cls,field.name,field)
+    """
+    setattr(_getcls(cls), field.name, field)
+
+
+def removeField(cls, field):
+    """Remove a particular field/event to the class/prototype definition
+
+    If field is a string, calls delattr(cls,field) for the class
+    otherwise calls delattr( cls, field.name )
+    """
+    if isinstance(field, str):
+        delattr(_getcls(cls), field)
+    else:
+        delattr(_getcls(cls), field.name)
+
+
+def getField(cls, field):
+    """Get a field/event object for the given name
+
+    field -- a field-name specifier, which may be any of
+        the following, (with the various options checked in
+        order, so that earlier options will take
+        precedence over later options):
+
+        * the exact name of the field/demand as specified
+            in the class's namespace (fastest and first
+            checked)
+        * the "storage" name of a field, that is, the "name"
+            attribute of a field where that name does not
+            match the previous definition (commonly seen in
+            non-standard fields on VRML97 standard nodes)
+        * the "storage" name of an event
+        * a pseudo-event with the prefix "set_" or the
+            suffix "_changed", which will return the
+            associated field/event as if the suffix were
+            not present (does a recursive call with the
+            truncated name)
+    """
+    cls = _getcls(cls)
+    try:
+        return getattr(cls, field)
+    except (AttributeError, KeyError):
+        # OK, may be a space-prefixed name...
+        for fieldObject in getFields(cls):
+            if fieldObject.name == field:
+                return field
+        # OK, may be an event with space-prefixed name
+        for fieldObject in getFields(cls, 1):
+            if fieldObject.name == field:
+                return field
+        # OK, may be one of the "component" events
+        # of a field...
+        if field.startswith("set_"):
+            return getField(cls, field[4:])
+        elif field.endswith("_changed"):
+            return getField(cls, field[:-8])
+    raise AttributeError(
+        """The prototype %s does not define a field named %s"""
+        % (protoName(cls), field)
+    )
+
+
+def getFields(cls, events=0):
+    """Get all fields of the definition/prototype
+
+    if events is true, then return events
+    instead of fields.
+    """
+    cls = _getcls(cls)
+    from vrml import field
+
+    if events:
+        wanted = field.Event
+    else:
+        wanted = field.Field
+    items = {}
+    mro = cls.__mro__[:]
+    while mro:
+        items.update(
+            dict(
+                [
+                    (key, value)
+                    for key, value in mro[-1].__dict__.items()
+                    if isinstance(value, wanted)
+                ]
+            )
+        )
+        mro = mro[:-1]
+    return list(items.values())
+
+
+##def clonePROTO( cls ):
+##	"""Clone the prototype/class
+##
+##	This allows you to create a new prototype from the
+##	current prototype.  The entire prototype is cloned,
+##	including all fields, and the scene graph.
+##	"""
+##	cls = _getcls(cls)
+##	fields = [ item.clone() for item in cls.__dict__.values() if isinstance(item, field.Field)]
+##	return prototype(
+##		cls.PROTO,
+##		fields,
+##		cls.sceneGraph.clone(),
+##	)
+
+
+def setSceneGraph(cls, sg):
+    """Set the scenegraph associated with a prototype"""
+    from vrml import node
+
+    return node.PrototypedNode.scenegraph.fset(cls, sg)
+
+
+def getSceneGraph(cls):
+    """Get the scenegraph associated with a prototype (or None)"""
+    from vrml import node
+
+    return node.PrototypedNode.scenegraph.fget(cls)
+
+
+def delSceneGraph(cls):
+    """Delete the scenegraph associated with a prototype"""
+    from vrml import node
+
+    return node.PrototypedNode.scenegraph.fdel(cls)
+
+
+def setExternalURL(cls, url):
+    """Set the externproto URL associated with a prototype"""
+    from vrml import node
+
+    return node.Node.externalURL.fset(cls, url)
+
+
+def getExternalURL(cls):
+    """Get the externproto URL associated with a prototype (or [])"""
+    from vrml import node
+
+    return node.Node.externalURL.fget(cls)
+
+
+def delExternalURL(cls):
+    """Delete the externproto URL associated with a prototype"""
+    from vrml import node
+
+    return node.Node.externalURL.fdel(cls)

vrml/protonamespace.py

@@ -0,0 +1,13 @@
+"""Trivial dict sub-class to hold prototype definitions"""
+class ProtoNamespace( dict ):
+    """Simple namespace for holding prototypes"""
+    def __getattr__( self, key ):
+        """Map attribute access to key access"""
+        if key != '__contains__':
+            if key in self:
+                return self[ key ]
+        raise AttributeError( '%r object has no %r attribute'%( self.__class__.__name__, key))
+    def __copy__( self ):
+        """Produce a ProtoNamespace copy of self"""
+        return self.__class__( super(ProtoNamespace,self).__copy__())
+    

vrml/route.py

@@ -0,0 +1,167 @@
+"""ROUTE and ISRoute Implementations (event-processing)"""
+import traceback
+from vrml import field, fieldtypes, protofunctions, node
+from pydispatch import dispatcher
+
+class ROUTE( node.Node ):
+    """Representation and implementation of a VRML97 ROUTE
+
+    This implementation uses the dispatcher module to create
+    an approximation of the VRML97 event model.  It allows nodes
+    to forward events via the ROUTE objects, and watches for
+    event cycles.
+    """
+    PROTO = "ROUTE"
+    source = node.SFNode('source',)
+    sourceField = fieldtypes.SFString('sourceField',)
+    destination = node.SFNode('destination',)
+    destinationField = fieldtypes.SFString( 'destinationField',)
+    def __init__( self, *arguments, **named ):
+        """Initialize the route object
+
+        Calls self.bind() after normal node.Node
+        argument processing.
+        """
+        if arguments:
+            if len(arguments) == 4:
+                named['source'] = arguments[0]
+                named['sourceField'] = arguments[1]
+                named['destination'] = arguments[2]
+                named['destinationField'] = arguments[3]
+                arguments = ()
+        super( ROUTE, self ).__init__( *arguments, **named )
+        self.bind()
+    def bind( self ):
+        """Bind this ROUTE node's source to destination
+
+        Should also setup notification for changes to our
+        values to cause changes to the ROUTING table in
+        dispatcher.
+        """
+        return self._bind( self.source, self.sourceField )
+    def _bind( self, source, field ):
+        """Low-level binding of the source,field key
+
+        This method allows sub-classes to do multiple
+        bindings when bind() is called.
+        """
+        if source and field:
+            try:
+                sf = protofunctions.getField( source, field )
+            except (AttributeError, KeyError):
+                print("""%s: field %s doesn't exist on %s"""%(protofunctions.protoName(self), field, source))
+            else:
+                for message in ('set','del','route'):
+                    dispatcher.connect(
+                        receiver = self.forward,
+                        sender = source,
+                        signal = (message,sf),
+                    )
+        else:
+            print("""NULL ROUTE bound""", self)
+    def forward( 
+        self, signal, sender, event=None, value=None, **arguments 
+    ):
+        """Forward a value update to our destination
+        """
+        return self._forward(
+            sender, signal, 
+            self.destination, self.destinationField,
+            event, value, **arguments
+        )
+    def _forward(
+        self,
+        sender, signal,
+        destination, destinationField,
+        event=None, value=None, **arguments
+    ):
+        """Do the low-level forwarding of the value to a target field"""
+        if event is None:
+            from vrml import event as eventmodule
+            event = eventmodule.Event()
+        signal, sourceField = signal
+        if signal == 'del':
+            value = sourceField.fget( sender )
+        if destination and destinationField:
+            destinationField = protofunctions.getField( destination, destinationField )
+            if event and hasattr(event, "visited"):
+                if event.visited((destination, destinationField),):
+                    ### Short-circuit before a cycle is created...
+                    return
+                event.visited( (destination,destinationField), 1)
+            if isinstance( destinationField, field.Field ):
+                try:
+                    value = destinationField.fset( destination, value, notify = 0 )
+                except (ValueError, TypeError):
+                    traceback.print_exc()
+            else:
+                try:
+                    value = destinationField.__set__( destination, value )
+                except (ValueError, TypeError):
+                    traceback.print_exc()
+            dispatcher.send(
+                signal = ('route',destinationField),
+                sender = destination,
+                value = value,
+                event = event,
+            )
+    def copy( self, copier ):
+        """Copy the route for the copier object"""
+        source = self.source.copy(copier)
+        destination = self.destination.copy( copier )
+        return self.__class__(
+            source = source,
+            destination = destination,
+            sourceField = self.sourceField,
+            destinationField = self.destinationField,
+        )
+    def __str__( self ):
+        """Get a friendly representation of the Node"""
+        return """%s %r.%s TO %r.%s"""%(
+            self.__class__.__name__,
+            self.source,
+            self.sourceField,
+            self.destination,
+            self.destinationField,
+        )
+        
+
+### Field-type for multi-field route objects...
+class SFRoute( node.SFNode ):
+    """Single-field ROUTE value"""
+    requiredTypes = (ROUTE,)
+
+class MFRoute( node.MFNode ):
+    """Multiple-value-field ROUTEs"""
+    baseSFNode = SFRoute( "GeneralSFRoute" )
+
+class IS( ROUTE ):
+    """An is-mapping for a field/event
+
+    Functionally, an instantiated IS is just a
+    multi-directional ROUTE (that is, it's a route
+    to and from a given field on the base node to
+    the sub-nodes.
+    """
+    PROTO = "IS"
+    def bind( self ):
+        """Bind the in and out routes for the IS mapping
+        """
+        self._bind( self.source, self.sourceField )
+        self._bind( self.destination, self.destinationField )
+    def forward( self, signal, sender, event=None, value=None, **arguments ):
+        """Forward a value update to our destination (or source)
+        """
+        if sender is self.source:
+            return self._forward(
+                sender, signal, 
+                self.destination, self.destinationField,
+                event, value, **arguments
+            )
+        elif sender is self.destination:
+            return self._forward(
+                sender, signal, 
+                self.source, self.sourceField,
+                event, value, **arguments
+            )
+        

vrml/vrml200x/parser.py

@@ -0,0 +1,87 @@
+"""VRML200X SimpleParse 2 Parser
+
+VRML200x is a fairly minor modification to the VRML97 grammar,
+with almost all of the changes being the more involved header,
+and a few new field-types that are already accepted by the
+VRML97 grammar.
+"""
+from simpleparse.parser import Parser
+from simpleparse.common import chartypes
+
+#print file
+grammar = r'''
+header         := headerStatement,profileStatement,componentStatement*,metaStatement*
+headerStatement  := ('#X3D',ts,SFNumber,ts,'utf8',ts,headerComment?,newLine)/('#',headerComment?,newLine)
+headerComment  := -newLine+
+profileStatement := 'PROFILE', ts, profileName,newLine
+profileName    := name
+<newLine>      := ('\r\n'/'\r'/'\n')
+
+componentStatement := 'COMPONENT',ts, componentNameId, ts,':', ts, componentSupportLevel
+componentNameId := name
+componentSupportLevel := SFNumber
+
+metaStatement  := 'META',ts, metakey,ts,metavalue
+metakey        := SFString
+metavalue      := SFString
+
+# not in the grammar, but apparently part of the VRML200x encoding
+importStatement := 'IMPORT',ts,name,ts,'.',ts,name,(ts,asClause)?,ts
+exportStatement := 'EXPORT',ts,name,(ts,asClause)?,ts
+asClause       := 'AS',ts,name
+
+vrmlFile       := header, vrmlScene, !, EOF
+vrmlScene      := rootItem*
+rootItem       := ts,(Proto/ExternProto/ROUTE/('USE',ts,USE,ts)/Script/Node),ts
+
+Proto          := 'PROTO',ts,!, nodegi,ts,'[',ts,(fieldDecl/eventDecl)*,']', ts, '{', ts, vrmlScene,ts, '}', ts
+fieldDecl	   := fieldExposure,ts,!,dataType,ts,name,ts,Field,ts
+
+# inputOutput/initializeOnly not in the grammar
+fieldExposure  := 'inputOutput'/'initializeOnly'/'field'/'exposedField'
+dataType       := ('SF'/'MF')?,name
+eventDecl      := eventDirection, ts, !,dataType, ts, name, ts
+
+# inputOnly/outputOnly not in the grammar
+eventDirection := 'inputOnly'/'outputOnly'/'eventIn'/'eventOut'
+ExternProto    := 'EXTERNPROTO',ts,!,nodegi,ts,'[',ts,(extFieldDecl/eventDecl)*,']', ts, ExtProtoURL
+extFieldDecl   := fieldExposure,ts,!,dataType,ts,name,ts
+ExtProtoURL    := '['?,(ts,SFString)*, ts, ']'?, ts  # just an MFString by another name :)
+
+ROUTE          := 'ROUTE',ts, !,name,'.',name, ts, 'TO', ts, name,'.',name, ts
+
+Node           := ('DEF',ts,!,name,ts)?,nodegi,ts,'{',ts,(Proto/ExternProto/ROUTE/Attr)*,ts,!,'}', ts
+
+Script         := ('DEF',ts,!,name,ts)?,'Script',ts,!,'{',ts,(ScriptFieldDecl/ScriptEventDecl/Proto/ExternProto/ROUTE/Attr)*,ts,'}', ts
+ScriptEventDecl := eventDirection, ts, !,dataType, ts, name, ts, ('IS', ts,!, IS,ts)?
+ScriptFieldDecl := fieldExposure,ts,!,dataType,ts,name,ts,(('IS', ts,!,IS,ts)/Field),ts
+
+SFNull         := 'NULL', ts
+
+# should really have an optimised way of declaring a different reporting name for the same production...
+USE            := name
+IS             := name
+nodegi         := name 
+Attr           := name, ts, (('IS', ts,IS,ts)/Field), ts
+Field          := ( '[',ts,((SFNumber/SFBool/SFString/('USE',ts,USE,ts)/Script/Node),ts)*, ']'!, ts )/((SFNumber/SFBool/SFNull/SFString/('USE',ts,USE,ts)/Script/Node),ts)+
+
+name           := -[][0-9{}\000-\020"'#,.\\ ],  -[][{}\000-\020"'#,.\\ ]*
+SFNumber       := [-+]*, ( ('0',[xX],[0-9A-Fa-f]+) / ([0-9.]+,([eE],[-+0-9.]+)?))
+SFBool         := 'TRUE'/'FALSE'
+SFString       := '"',(CHARNODBLQUOTE/ESCAPEDCHAR/SIMPLEBACKSLASH)*,'"'!
+CHARNODBLQUOTE :=  -[\134"]+
+SIMPLEBACKSLASH := '\134'
+ESCAPEDCHAR    := '\\"'/'\134\134'
+<ts>           :=  ( [ \011-\015,]+ / ('#',-'\012'*,'\n')+ )*
+'''
+
+class VRMLParser( Parser ):
+    """Simple subclassing of Parser to create proper ParseProcessor"""
+    def buildProcessor( self ):
+        """Build and return a vrml.vrml97.parseprocessor.ParseProcessor"""
+        from vrml.vrml97 import parseprocessor
+        return parseprocessor.ParseProcessor()
+
+def buildParser( declaration = grammar ):
+    """Build a new VRMLParser object"""
+    return VRMLParser( declaration, "vrmlFile" )

vrml/vrml97/__init__.py

@@ -0,0 +1,6 @@
+"""VRML97-specific customisations and support
+
+Includes a full VRML97 parser and lineariser
+for SimpleParse 2.0.x
+"""
+