PyVRML97 2.3.4b3__py3-none-any.whl

vrml/csscolors.py

@@ -0,0 +1,177 @@
+"""Module to allow using strings to specify colors"""
+def stringToColor( value ):
+    """Given a string/unicode value, determine appropriate color"""
+    value = value.lower()
+    possible = cssColors.get( value )
+    if possible:
+        return possible
+    if value and value[0] == '#':
+        # HTML-style #hex encoding
+        possible = int( value[1:],16)
+        return toFloat(possible,16),toFloat(possible,8), toFloat(possible,0)
+    else:
+        raise ValueError( """String %(value)r couldn't be recognised as a color name, or #FFFFFF style encoding"""%locals())
+def toInt( value ):
+    """Take float value and give single-byte integer equivalent"""
+    return int(round(value*255,0))
+def toFloat( value, shift=0 ):
+    """Take single-byte integer value return floating point equivalent"""
+    return ((value&(255<<shift))>>shift)/255.0
+    
+
+cssColors = {
+    'black' : (0.0,0.0,0.0),
+    'dimgray' : (0.4118,0.4118,0.4118),
+    'gray' : (0.502,0.502,0.502),
+    'darkgray' : (0.6627,0.6627,0.6627),
+    'silver' : (0.7529,0.7529,0.7529),
+    'lightgrey' : (0.8275,0.8275,0.8275),
+    'gainsboro' : (0.8627,0.8627,0.8627),
+    'whitesmoke' : (0.9608,0.9608,0.9608),
+    'white' : (1.0,1.0,1.0),
+    'snow' : (1.0,0.9804,0.9804),
+    'rosybrown' : (0.7373,0.5608,0.5608),
+    'lightcoral' : (0.9412,0.502,0.502),
+    'indianred' : (0.8039,0.3608,0.3608),
+    'brown' : (0.6471,0.1647,0.1647),
+    'firebrick' : (0.698,0.1333,0.1333),
+    'maroon' : (0.502,0.0,0.0),
+    'darkred' : (0.5451,0.0,0.0),
+    'red' : (1.0,0.0,0.0),
+    'mistyrose' : (1.0,0.8941,0.8824),
+    'salmon' : (0.9804,0.502,0.4471),
+    'tomato' : (1.0,0.3882,0.2784),
+    'darksalmon' : (0.9137,0.5882,0.4784),
+    'coral' : (1.0,0.498,0.3137),
+    'orangered' : (1.0,0.2706,0.0),
+    'lightsalmon' : (1.0,0.6275,0.4784),
+    'sienna' : (0.6275,0.3216,0.1765),
+    'seashell' : (1.0,0.9608,0.9333),
+    'chocolate' : (0.8235,0.4118,0.1176),
+    'saddlebrown' : (0.5451,0.2706,0.0745),
+    'sandybrown' : (0.9569,0.6431,0.3765),
+    'peachpuff' : (1.0,0.8549,0.7255),
+    'peru' : (0.8039,0.5216,0.2471),
+    'linen' : (0.9804,0.9412,0.902),
+    'bisque' : (1.0,0.8941,0.7686),
+    'burlywood' : (0.8706,0.7216,0.5294),
+    'darkorange' : (1.0,0.549,0.0),
+    'antiquewhite' : (0.9804,0.9216,0.8431),
+    'tan' : (0.8235,0.7059,0.549),
+    'blanchedalmond' : (1.0,0.9216,0.8039),
+    'navajowhite' : (1.0,0.8706,0.6784),
+    'papayawhip' : (1.0,0.9373,0.8353),
+    'moccasin' : (1.0,0.8941,0.7098),
+    'oldlace' : (0.9922,0.9608,0.902),
+    'wheat' : (0.9608,0.8706,0.702),
+    'orange' : (1.0,0.6471,0.0),
+    'floralwhite' : (1.0,0.9804,0.9412),
+    'goldenrod' : (0.8549,0.6471,0.1255),
+    'cornsilk' : (1.0,0.9725,0.8627),
+    'gold' : (1.0,0.8431,0.0),
+    'lemonchiffon' : (1.0,0.9804,0.8039),
+    'palegoldenrod' : (0.9333,0.9098,0.6667),
+    'khaki' : (0.9412,0.902,0.549),
+    'darkkhaki' : (0.7412,0.7176,0.4196),
+    'ivory' : (1.0,1.0,0.9412),
+    'beige' : (0.9608,0.9608,0.8627),
+    'lightyellow' : (1.0,1.0,0.8784),
+    'lightgoldenrodyellow' : (0.9804,0.9804,0.8235),
+    'darkgoldenrod' : (0.7216,0.7137,0.0431),
+    'olive' : (0.502,0.502,0.0),
+    'yellow' : (1.0,1.0,0.0),
+    'yellowgreen' : (0.6627,0.8039,0.1961),
+    'olivedrab' : (0.4196,0.5569,0.1373),
+    'darkolivegreen' : (0.3333,0.4196,0.1843),
+    'greenyellow' : (0.6784,1.0,0.1843),
+    'chartreuse' : (0.498,1.0,0.0),
+    'lawngreen' : (0.4863,0.9882,0.0),
+    'honeydew' : (0.9412,1.0,0.9412),
+    'darkseagreen' : (0.5608,0.7373,0.5608),
+    'lightgreen' : (0.5647,0.9333,0.5647),
+    'palegreen' : (0.5961,0.9843,0.5961),
+    'forestgreen' : (0.1333,0.5451,0.1333),
+    'limegreen' : (0.1961,0.8039,0.1961),
+    'darkgreen' : (0.0,0.3922,0.0),
+    'green' : (0.0,0.502,0.0),
+    'lime' : (0.0,1.0,0.0),
+    'mediumseagreen' : (0.2353,0.702,0.4431),
+    'seagreen' : (0.1804,0.5451,0.3412),
+    'mintcream' : (0.9608,1.0,0.9804),
+    'springgreen' : (0.0,1.0,0.498),
+    'mediumspringgreen' : (0.0,0.9804,0.6039),
+    'mediumaquamarine' : (0.4,0.8039,0.6667),
+    'aquamarine' : (0.498,1.0,0.8314),
+    'turquoise' : (0.251,0.8784,0.8157),
+    'mediumturquoise' : (0.2824,0.8196,0.8),
+    'lightseagreen' : (0.1255,0.698,0.6667),
+    'azure' : (0.9412,1.0,1.0),
+    'lightcyan' : (0.8784,1.0,1.0),
+    'paleturquoise' : (0.6863,0.9333,0.9333),
+    'darkslategray' : (0.1843,0.3098,0.3098),
+    'teal' : (0.0,0.502,0.502),
+    'darkcyan' : (0.0,0.5451,0.5451),
+    'aqua' : (0.0,1.0,1.0),
+    'cyan' : (0.0,1.0,1.0),
+    'cadetblue' : (0.3725,0.6196,0.6275),
+    'darkturquoise' : (0.0,0.8078,0.8196),
+    'powderblue' : (0.6902,0.8784,0.902),
+    'lightblue' : (0.6784,0.8471,0.902),
+    'deepskyblue' : (0.0,0.749,1.0),
+    'skyblue' : (0.5294,0.8078,0.9294),
+    'lightskyblue' : (0.5294,0.8078,0.9804),
+    'steelblue' : (0.2745,0.5098,0.7059),
+    'aliceblue' : (0.9412,0.9725,1.0),
+    'slategray' : (0.4392,0.502,0.5647),
+    'lightslategray' : (0.4667,0.5333,0.6),
+    'dodgerblue' : (0.1176,0.5647,1.0),
+    'lightsteelblue' : (0.6902,0.7686,0.8706),
+    'cornflowerblue' : (0.3922,0.5843,0.9294),
+    'royalblue' : (0.0157,0.0863,0.5647),
+    'ghostwhite' : (0.9725,0.9725,1.0),
+    'lavender' : (0.902,0.902,0.9804),
+    'midnightblue' : (0.098,0.098,0.4392),
+    'navy' : (0.0,0.0,0.502),
+    'darkblue' : (0.0,0.0,0.5451),
+    'mediumblue' : (0.0,0.0,0.8039),
+    'blue' : (0.0,0.0,1.0),
+    'darkslateblue' : (0.2824,0.2392,0.5451),
+    'slateblue' : (0.4157,0.3529,0.8039),
+    'mediumslateblue' : (0.4824,0.4078,0.9333),
+    'mediumpurple' : (0.5765,0.4392,0.8588),
+    'blueviolet' : (0.5412,0.1686,0.8863),
+    'indigo' : (0.2941,0.0,0.5098),
+    'darkorchid' : (0.6,0.1961,0.8),
+    'darkviolet' : (0.5804,0.0,0.8275),
+    'mediumorchid' : (0.7294,0.3333,0.8275),
+    'thistle' : (0.8471,0.749,0.8471),
+    'plum' : (0.8667,0.6275,0.8667),
+    'violet' : (0.9333,0.5098,0.9333),
+    'purple' : (0.502,0.0,0.502),
+    'darkmagenta' : (0.5451,0.0,0.5451),
+    'fuchsia' : (1.0,0.0,1.0),
+    'magenta' : (1.0,0.0,1.0),
+    'orchid' : (0.8549,0.4392,0.8392),
+    'mediumvioletred' : (0.7804,0.0824,0.5216),
+    'deeppink' : (1.0,0.0784,0.5765),
+    'hotpink' : (1.0,0.4118,0.7059),
+    'lavenderblush' : (1.0,0.9412,0.9608),
+    'palevioletred' : (0.8588,0.4392,0.5765),
+    'pink' : (1.0,0.7529,0.8039),
+    'crimson' : (0.8627,0.0784,0.2353),
+    'lightpink' : (1.0,0.7137,0.7569),
+}
+
+if __name__ == "__main__":
+    import unittest
+    from vrml import arrays
+    class ColorTests(unittest.TestCase):
+        def testForwardName (self):
+            for name, value in cssColors.items():
+                assert stringToColor( name ) == value
+        def testForwardHexidecimal (self):
+            for name, value in cssColors.items ():
+                representation = '#%02x%02x%02x'%tuple(map(toInt,value))
+                result = stringToColor( representation )
+                assert arrays.allclose( result, value, 0.001), """Expected %r, got %r"""%(value, result)
+    unittest.main ()

vrml/event.py

@@ -0,0 +1,24 @@
+"""Routable event base-class for VRML environments"""
+
+class Event( object ):
+    """Routable event for VRML environments"""
+    def __init__( self ):
+        """Initialize the Event object"""
+        self.visitedNodes = {}
+    def visited (self, key, value = None):
+        """Check for or register visitation of the given key
+
+        key -- an opaque hashable value, normally the node and
+            field/event as a tuple.
+        value -- if provided, sets the current value, otherwise
+            signals that the current value should be returned
+
+        return value: previous key value (possibly None)
+        """
+        if value is None:
+            return self.visitedNodes.get(key)
+        else:
+            previousValue = self.visitedNodes.get(key)
+            self.visitedNodes[key] = value
+            return previousValue
+    

vrml/field.py

@@ -0,0 +1,476 @@
+"""property sub-class providing VRML field semantics"""
+
+from pydispatch import dispatcher, robustapply
+import weakref
+import sys
+from vrml import protonamespace
+
+# conditional import via package entry points
+try:
+    from vrml_accelerate import fieldaccel2
+except Exception as err:
+    fieldaccel2 = None
+
+from ._bytes import bytes, unicode, long
+
+baseFieldTypes = protonamespace.ProtoNamespace({})
+baseEventTypes = protonamespace.ProtoNamespace({})
+
+### stuff used by the various field sub-types
+NUMERIC_TYPES = (int, float, long)
+SEQUENCE_TYPES = (tuple, list)
+if sys.version_info[0] >= 3:
+    MAP_TYPE = type(map(int, [0]))
+    ZIP_TYPE = type(zip([], []))
+    RANGE_TYPE = type(range(3))
+    UNPACK_TYPES = (MAP_TYPE, ZIP_TYPE, RANGE_TYPE)
+    SEQUENCE_TYPES += UNPACK_TYPES
+else:
+    MAP_TYPE = None
+    ZIP_TYPE = None
+    RANGE_TYPE = type(xrange(3))
+    UNPACK_TYPES = ()
+_NULL = []
+
+
+def register(cls):
+    """Register a new Field or Event class"""
+    name = typeName(cls)
+    if issubclass(cls, Event):
+        dictionary = baseEventTypes
+    else:
+        dictionary = baseFieldTypes
+    if name in dictionary:
+        print(
+            'Warning: redefining field-type %s from %s to %s'
+            % (name, dictionary.get(name), cls)
+        )
+    dictionary[name] = cls
+
+
+def typeName(cls):
+    """Get the name of a field/event"""
+    if hasattr(cls, 'fieldType'):
+        return cls.fieldType
+    else:
+        return cls.__name__.split('.')[-1]
+
+
+def newField(name, dataType, exposure=1, default=_NULL):
+    """Create a new field with support for using strings to specify type
+
+    name -- string name
+    dataType -- string (or Field sub-class) specifying datatype
+    exposure -- boolean (0/1) indicating whether this is an exposed field
+    default -- default value for the field
+    """
+    if isinstance(dataType, (bytes, unicode)):
+        dataType = baseFieldTypes[dataType]
+    return dataType(name, exposure, default)
+
+
+def newEvent(name, dataType, direction=1):
+    """Create a new event object (a specialised Field)
+    name -- string name
+    dataType --
+    direction -- 0 == in, 1 == out
+    """
+    if isinstance(dataType, (bytes, unicode)):
+        dataType = baseEventTypes[dataType]
+    return dataType(name, direction)
+
+
+if fieldaccel2:
+    BaseField = fieldaccel2.BaseField
+else:
+
+    class BaseField(object):
+        def __init__(self, name, default):
+            self.name = name
+            self.defaultobj = default
+            if hasattr(default, '__call__'):
+                self.call_default = True
+            else:
+                self.call_default = False
+
+        def __get__(self, client, cls=None):
+            """Retrieve value for given instance (or self for cls)"""
+            if client is None:
+                return self
+            idict = client.__dict__
+            current = idict.get(self.name, _NULL)
+            if current is _NULL:
+                return self.getDefault(client)
+            return current
+
+        fget = __get__
+
+        def __set__(self, client, value):
+            """Set value for given instance"""
+            value = self._set(client, value)
+            dispatcher.send(
+                ('set', self),
+                client,
+                value=value,
+            )
+            # return value
+
+        def fset(self, client, value, notify=True):
+            value = self._set(client, value)
+            if notify:
+                dispatcher.send(
+                    ('set', self),
+                    client,
+                    value=value,
+                )
+            return value
+
+        def _set(self, client, value):
+            try:
+                value = self.coerce(value)
+            except ValueError as x:
+                raise ValueError(
+                    """Field %s could not accept value %s (%s)""" % (self, value, x)
+                )
+            except TypeError as x:
+                raise ValueError(
+                    """Field %s could not accept value %s of type %s (%s)"""
+                    % (self, value, type(value), x)
+                )
+            if isinstance(client, type):
+                setattr(client, self.name, value)
+            else:
+                client.__dict__[self.name] = value
+            return value
+
+        def coerce(self, value):
+            """Coerce the given value to our type"""
+            return value
+
+        def check(self, value):
+            "Raise ValueError if isn't correct type"
+            return value
+
+        def getDefault(self, client=None):
+            """Get the default value of this field
+
+            if client, set client's attribute to default
+            without sending a notification event.
+            """
+            if self.call_default:
+                defaultobj = self.defaultobj()
+            else:
+                defaultobj = self.defaultobj
+            if client is not None:
+                defaultobj = self._set(client, defaultobj)
+            return defaultobj
+
+        def __delete__(self, client):
+            """Delete our value from client's dictionary"""
+            try:
+                client.__dict__[self.name]
+            except KeyError:
+                raise AttributeError(self.name)
+
+        def fdel(self, client, notify=True):
+            """Delete with notify"""
+            self.__delete__(client)
+            if notify:
+                dispatcher.send(
+                    ('del', self),
+                    client,
+                )
+
+
+class Field(BaseField):
+    """Property sub-class with VRML field semantics
+
+    The field basically binds a name, a dataType, and
+    a default value (with some other meta-data that isn't
+    actually used by the current implementation).
+
+    Fields are normally accessed through the protofunctions
+    module, which retrieves field objects from node or
+    prototype objects.
+
+    The field offers vrml.dispatcher notification of
+    changes to values (see fget, fset and fdel methods).
+    Which allows code to watch for those changes, a
+    facility you can see in the OpenGLContext.scenegraph.cache
+    module.
+    """
+
+    nodes = 0
+    defaultDefault = None
+
+    def __init__(
+        self,
+        name,
+        exposure=1,
+        default=_NULL,
+    ):
+        """Initialise the field object
+
+        name -- string name
+        exposure -- boolean (0/1) indicating whether this is an exposed field
+        default -- default value for the field
+        """
+        self.exposure = exposure
+        if default is _NULL:
+            default = self.defaultDefault
+        super(Field, self).__init__(name, default)
+        setattr(self, "__doc__", str(self))
+
+    def fhas(self, client):
+        """Determine whether the client currently has a non-default value"""
+        if isinstance(client, type):
+            return hasattr(client, self.name)
+        elif self.name in client.__dict__:
+            return 1
+        else:
+            return 0
+
+    def copy(self, client=None, copier=None):
+        """Copy this property's value/definition for client node/proto
+
+        if client is a prototype, copy this field definition
+        for use in a new prototype.
+
+        if client is a node, and it has a set value for this
+        field, then returns self.copyValue( currentValue )
+
+        otherwise returns _NULL, a singleton object which
+        shouldn't turn up anywhere else.
+        """
+        if isinstance(client, type):
+            # copy the field definition itself...
+            return self.__class__(
+                self.name,
+                self.exposure,
+                self.copyValue(self.defaultobj, copier),
+            )
+        elif self.fhas(client):
+            return self.copyValue(self.fget(client), copier)
+        else:
+            return _NULL
+
+    def copyValue(self, value, copier=None):
+        """Copy a value for copier"""
+        return value
+
+    def typeName(self):
+        """Get the typeName of this field"""
+        return typeName(self.__class__)
+
+    def __str__(self):
+        """Get a human-friendly representation of the field"""
+        if self.exposure:
+            exposed = "exposedField"
+        else:
+            exposed = "field"
+        if self.defaultobj is list:
+            default = '[]'
+        else:
+            default = str(self.defaultobj)[:20]
+        return '%s %s %s %s' % (
+            exposed,
+            self.typeName(),
+            self.name,
+            default,
+        )
+
+    def vrmlstr(self, value, lineariser):
+        """Convert the given value to a VRML97 representation"""
+        return ""
+
+    def fieldVrmlstr(self, lineariser):
+        """Write the field's definition to the lineariser
+
+        Basically this gives you a VRML97 fragment
+        which can be used for creating a PROTO which
+        will have the equivalent of this field available.
+        """
+        if self.exposure:
+            exposed = "exposedField"
+        else:
+            exposed = "field"
+        lineariser.buffer.write(
+            '%s %s %s '
+            % (
+                exposed,
+                self.typeName(),
+                self.name,
+            )
+        )
+        result = self.vrmlstr(
+            # coerce is necessary because the
+            # default values are often not in
+            # the canonical representation
+            self.coerce(self.getDefault()),
+            lineariser,
+        )
+        if result:
+            lineariser.buffer.write(result)
+        return
+
+    def watch(self, node, receiver, signal=dispatcher.Any):
+        """Make receiver receive all update events for this field+node
+
+        receiver( signal, sender, value=None )
+
+            signal -- ('del',self), ('set',self) etc...
+            sender -- node
+            value -- new value set (for set values)
+        """
+        return dispatcher.connect(
+            receiver=receiver,
+            sender=node,
+            signal=signal,
+        )
+
+    def __lt__(self, other):
+        if isinstance(other, Field):
+            return (self.__class__.__name__, self.name) < (
+                other.__class__.__name__,
+                other.name,
+            )
+        return False
+
+
+class WeakField(object):
+    """A Mix-in for fields which stores weak-references to values"""
+
+    def fset(self, client, value, notify=1):
+        """Set the client's value for this property
+
+        if notify is true send a notification event.
+        """
+        if isinstance(value, weakref.ReferenceType):
+            value = value()
+        if not value:
+            if not isinstance(client, type):
+                self.fdel(client, notify=notify)
+            return None
+        value = weakref.ref(value)
+        value = super(WeakField, self).fset(client, value, notify=notify)
+        return value()
+
+    def fget(self, client):
+        """Get the client's value for this property
+
+        if notify is true send a notification event.
+        """
+        value = super(WeakField, self).fget(client)
+        if not value:
+            # is already default value, since refs are always non-null
+            return value
+        if isinstance(value, weakref.ReferenceType):
+            value = value()
+        # value now really is the ref'd value, or None
+        if value is None:
+            if not isinstance(client, type):
+                self.fdel(client, notify=0)
+            return None  # super( WeakField, self).fget( client )
+        return value
+
+
+class Event(object):
+    """An Event-handling Port definition
+
+    The event is currently non-functional, it's just
+    here to allow VRML content to parse and be represented
+    in-memory.
+    """
+
+    def __init__(self, name, direction=1):
+        """Initialise the field object
+
+        name -- string name
+        direction -- 0 == in, 1 == out
+        """
+        self.name = name
+        self.direction = direction
+
+    def __set__(self, client, value, notify=1):
+        """Set an event value"""
+        method = getattr(client, 'on_%s' % (self.name,), None)
+        if method is not None:
+            robustapply.robustApply(
+                method,
+                value,
+                event=self,
+            )
+        # now set as a normal property...
+        client.__dict__[self.name] = value
+        # and then send event letting world know...
+        if notify:
+            dispatcher.send(('set', self), client, value=value)
+
+    def __get__(self, client=None, cls=None):
+        """Get an event's last value"""
+        if client is None:
+            return self
+        try:
+            return client.__dict__[self.name]
+        except KeyError:
+            raise AttributeError(
+                """Event %s doesn't have a value for %s"""
+                % (
+                    self.name,
+                    client,
+                )
+            )
+
+    def clone(self, name=None, direction=None):
+        """Clone this property"""
+        if name is None:
+            name = self.name
+        if direction is None:
+            direction = self.direction
+        return self.__class__(name, direction)
+
+    def typeName(self):
+        """Get the typeName of this field"""
+        return typeName(self.__class__)
+
+    def __str__(self):
+        """Get a human-friendly representation of the event"""
+        if self.direction:
+            exposed = "eventOut"
+        else:
+            exposed = "eventIn"
+        return '%s %s %s' % (exposed, self.typeName(), self.name)
+
+    def eventVrmlstr(self, lineariser):
+        """Write the event's definition to the lineariser
+
+        Basically this gives you a VRML97 fragment
+        which can be used for creating a PROTO which
+        will have the equivalent of this event available.
+        """
+        if self.direction:
+            exposed = "eventOut"
+        else:
+            exposed = "eventIn"
+        base = '%s %s %s' % (
+            exposed,
+            self.typeName(),
+            self.name,
+        )
+        lineariser.buffer.write(base)
+        return base
+
+    def watch(self, node, receiver, signal=dispatcher.Any):
+        """Make receiver receive all update events for this field+node
+
+        receiver( signal, sender, value=None )
+
+            signal -- ('del',self), ('set',self) etc...
+            sender -- node
+            value -- new value set (for set values)
+        """
+        return dispatcher.connect(
+            receiver=receiver,
+            sender=node,
+            signal=signal,
+        )