text:
from zope.interface import implementer

from interfaces import ISerializer

import urlparse, urllib

def parse_wamp_uri(bytes):
   try:
      uri = urllib.unquote(bytes).decode('utf8')
      parsed = urlparse.urlparse(uri)
   except:
      return None

   if parsed.scheme not in ["http", "https"]:
      return None

   if parsed.port is not None:
      return None

   if parsed.query is not None and parsed.query != "":
      return None

   return uri

def parse_wamp_sessionid(string):
   ## FIXME: verify/parse WAMP session ID
   return string

def parse_wamp_callid(string):
   ## FIXME: verify/parse WAMP call ID
   return string

class Message:
   """
   WAMP message base class.
   """
   def __init__(self):
      self.resetSerialization()

   def resetSerialization(self):
      ## serialization cache: mapping from ISerializer instances
      ## to serialized bytes
      ##
      self._serialized = {}

   def serialize(self, serializer):
      if not self._serialized.has_key(serializer):
         #print "Message.serialize [new]", serializer
         self._serialized[serializer] = serializer.serialize(self.marshal())
      else:
         #print "Message.serialize [cached]", serializer
         pass

      return self._serialized[serializer]

   def __eq__(self, other):
      return (isinstance(other, self.__class__) and self.__dict__ == other.__dict__)

   def __ne__(self, other):
      return not self.__eq__(other)

class Error(Message):
   """
   A WAMP Error message.
   """

   MESSAGE_TYPE = 17
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, request, error, args = None, kwargs = None):
      """
      Message constructor.

      :param request: The WAMP request ID of the original request (`Call`, `Subscribe`, ...) this error occured for.
      :type request: int
      :param error: The WAMP or application error URI for the error that occured.
      :type error: str
      :param args: Exception positional values.
      :type args: list
      :param kwargs: Exception keyword values.
      :type kwargs: dict
      """
      assert(not (kwargs and not args))
      Message.__init__(self)
      self.request = request
      self.error = error
      self.args = args
      self.kwargs = kwargs

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Klass.MESSAGE_TYPE)

      if len(wmsg) not in (4, 5, 6):
         raise WampProtocolError("invalid message length %d for WAMP Error message" % len(wmsg))

      ## request
      ##
      request = wmsg[1]
      if request != int:
         raise WampProtocolError("invalid type %s for 'request' in WAMP Error message" % type(request))

      ## error
      ##
      if type(wmsg[2]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'error' in WAMP Error message" % type(wmsg[2]))

      error = parse_wamp_uri(wmsg[2])
      if error is None:
         raise WampProtocolError("invalid value '%s' for 'error' in WAMP Error message" % wmsg[2])

      ## details
      ##
      details = wmsg[3]

      if type(details) != dict:
         raise WampProtocolError("invalid type %s for 'details' in WAMP Error message" % type(details))

      for k in details.keys():
         if type(k) not in (str, unicode):
            raise WampProtocolError("invalid type %s for key '%s' in 'details' in WAMP Error message" % (k, type(k)))

      ## exception
      ##
      args = None
      if len(wmsg) > 4:
         args = wmsg[4]
         if type(args) != list:
            raise WampProtocolError("invalid type %s for 'args' in WAMP Error message" % type(args))

      ## exceptionkw
      ##
      kwargs = None
      if len(wmsg) > 5:
         kwargs = wmsg[5]
         if type(kwargs) != dict:
            raise WampProtocolError("invalid type %s for 'kwargs' in WAMP Error message" % type(kwargs))

      obj = Klass(request, error, args = args, kwargs = kwargs)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      details = {}

      if self.kwargs:
         return [self.MESSAGE_TYPE, self.request, self.error, details, self.args, self.kwargs]
      elif self.args:
         return [self.MESSAGE_TYPE, self.request, self.error, details, self.args]
      else:
         return [self.MESSAGE_TYPE, self.request, self.error, details]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Error Message (request = {}, error = {}, exception = {}, exceptionkw = {})".format(self.request, self.error, self.exception, self.exceptionkw)

class Hello(Message):
   """
   A WAMP Hello message.
   """

   MESSAGE_TYPE = 1
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, sessionid):
      """
      Message constructor.

      :param sessionid: The WAMP session ID the other peer is assigned.
      :type sessionid: str
      """
      Message.__init__(self)
      self.sessionid = sessionid

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Hello.MESSAGE_TYPE)

      if len(wmsg) != 2:
         raise WampProtocolError("invalid message length %d for WAMP Hello message" % len(wmsg))

      ## sessionid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'sessionid' in WAMP Hello message" % type(wmsg[1]))

      sessionid = parse_wamp_sessionid(wmsg[1])
      if sessionid is None:
         raise WampProtocolError("invalid value '%s' for 'sessionid' in WAMP Hello message" % wmsg[1])

      obj = Klass(sessionid)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      return [Hello.MESSAGE_TYPE, self.sessionid]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Hello Message (sessionid = '%s')" % (self.sessionid)

class RoleChange(Message):
   """
   A WAMP Role-Change message.
   """

   MESSAGE_TYPE = 23
   """
   The WAMP message code for this type of message.
   """

   ROLE_CHANGE_OP_ADD = 1
   ROLE_CHANGE_OP_REMOVE = 2

   ROLE_CHANGE_OP_DESC = {
      ROLE_CHANGE_OP_ADD: 'add',
      ROLE_CHANGE_OP_REMOVE: 'remove'
   }

   ROLE_CHANGE_ROLE_BROKER = 'broker'
   ROLE_CHANGE_ROLE_DEALER = 'dealer'

   def __init__(self, op, role):
      """
      Message constructor.

      :param op: Role operation (add or remove role).
      :type op: int
      :param role: Role to be added or removed.
      :type role: str
      """
      Message.__init__(self)
      self.op = op
      self.role = role

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == RoleChange.MESSAGE_TYPE)

      if len(wmsg) != 3:
         raise WampProtocolError("invalid message length %d for WAMP Role-Change message" % len(wmsg))

      ## op
      ##
      op = wmsg[1]
      if type(op) != int:
         raise WampProtocolError("invalid type %s for 'op' in WAMP Role-Change message" % type(op))
      if op not in [RoleChange.ROLE_CHANGE_OP_ADD, RoleChange.ROLE_CHANGE_OP_REMOVE]:
         raise WampProtocolError("invalid value '%s' for 'op' in WAMP Role-Change message" % op)

      ## role
      ##
      role = wmsg[2]
      if type(role) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'role' in WAMP Role-Change message" % type(role))
      if role not in [RoleChange.ROLE_CHANGE_ROLE_BROKER, RoleChange.ROLE_CHANGE_ROLE_DEALER]:
         raise WampProtocolError("invalid value '%s' for 'role' in WAMP Role-Change message" % role)

      obj = Klass(op, role)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      return [RoleChange.MESSAGE_TYPE, self.op, self.role]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Role-Change Message (op = '%s', role = '%s')" % (RoleChange.ROLE_CHANGE_OP_DESC.get(self.op), self.role)

class Heartbeat(Message):
   """
   A WAMP Hearbeat message.
   """

   MESSAGE_TYPE = 2
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, incoming, outgoing):
      """
      Message constructor.

      :param incoming: Last incoming heartbeat processed from peer.
      :type incoming: int
      :param outgoing: Outgoing heartbeat.
      :type outgoing: int
      """
      Message.__init__(self)
      self.incoming = incoming
      self.outgoing = outgoing

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Heartbeat.MESSAGE_TYPE)

      if len(wmsg) != 3:
         raise WampProtocolError("invalid message length %d for WAMP Heartbeat message" % len(wmsg))

      ## incoming
      ##
      incoming = wmsg[1]

      if type(incoming) != int:
         raise WampProtocolError("invalid type %s for 'incoming' in WAMP Heartbeat message" % type(incoming))

      if incoming < 0: # must be non-negative
         raise WampProtocolError("invalid value %d for 'incoming' in WAMP Heartbeat message" % incoming)

      ## outgoing
      ##
      outgoing = wmsg[2]

      if type(outgoing) != int:
         raise WampProtocolError("invalid type %s for 'outgoing' in WAMP Heartbeat message" % type(outgoing))

      if outgoing <= 0: # must be positive
         raise WampProtocolError("invalid value %d for 'outgoing' in WAMP Heartbeat message" % outgoing)

      obj = Klass(incoming, outgoing)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      return [Heartbeat.MESSAGE_TYPE, self.incoming, self.outgoing]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Hearbeat Message (incoming %d, outgoing = %d)" % (self.incoming, self.outgoing)

class Subscribe(Message):
   """
   A WAMP Subscribe message.
   """

   MESSAGE_TYPE = 3
   """
   The WAMP message code for this type of message.
   """

   MATCH_EXACT = 1
   MATCH_PREFIX = 2
   MATCH_WILDCARD = 3

   MATCH_DESC = {MATCH_EXACT: 'exact', MATCH_PREFIX: 'prefix', MATCH_WILDCARD: 'wildcard'}

   def __init__(self, subscribeid, topic, match = MATCH_EXACT):
      """
      Message constructor.

      :param topic: The WAMP or application URI of the PubSub topic to subscribe to.
      :type topic: str
      :param match: The topic matching method to be used for the subscription.
      :type match: int
      """
      Message.__init__(self)
      self.subscribeid = subscribeid
      self.topic = topic
      self.match = match

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Subscribe.MESSAGE_TYPE)

      if len(wmsg) not in (3, 4):
         raise WampProtocolError("invalid message length %d for WAMP Subscribe message" % len(wmsg))

      ## subscribeid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'subscribeid' in WAMP Subscribe message" % type(wmsg[1]))

      subscribeid = parse_wamp_callid(wmsg[1])
      if subscribeid is None:
         raise WampProtocolError("invalid value '%s' for 'subscribeid' in WAMP Subscribe message" % wmsg[1])

      ## topic
      ##
      if type(wmsg[2]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for topic in WAMP Subscribe message" % type(wmsg[2]))

      topic = parse_wamp_uri(wmsg[2])
      if topic is None:
         raise WampProtocolError("invalid value '%s' for topic in WAMP Subscribe message" % wmsg[2])

      ## options
      ##
      match = Subscribe.MATCH_EXACT

      if len(wmsg) == 4:
         options = wmsg[3]

         if type(options) != dict:
            raise WampProtocolError("invalid type %s for options in WAMP Subscribe message" % type(options))

         for k in options.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in options in WAMP Subscribe message" % type(k))

         if options.has_key('match'):

            option_match = options['match']
            if type(option_match) != int:
               raise WampProtocolError("invalid type %s for 'match' option in WAMP Subscribe message" % type(option_match))

            if option_match not in [Subscribe.MATCH_EXACT, Subscribe.MATCH_PREFIX, Subscribe.MATCH_WILDCARD]:
               raise WampProtocolError("invalid value %d for 'match' option in WAMP Subscribe message" % option_match)

            match = option_match

      obj = Klass(subscribeid, topic, match)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      options = {}

      if self.match != Subscribe.MATCH_EXACT:
         options['match'] = self.match

      if len(options):
         return [Subscribe.MESSAGE_TYPE, self.subscribeid, self.topic, options]
      else:
         return [Subscribe.MESSAGE_TYPE, self.subscribeid, self.topic]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Subscribe Message (subscribeid = '%s', topic = '%s', match = %s)" % (self.subscribeid, self.topic, Subscribe.MATCH_DESC.get(self.match))

class Subscription(Message):
   """
   A WAMP Subscription message.
   """

   MESSAGE_TYPE = 103
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, subscribeid, subscriptionid):
      """
      Message constructor.

      :param topic: The WAMP or application URI of the PubSub topic to subscribe to.
      :type topic: str
      :param match: The topic matching method to be used for the subscription.
      :type match: int
      """
      Message.__init__(self)
      self.subscribeid = subscribeid
      self.subscriptionid = subscriptionid

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Subscription.MESSAGE_TYPE)

      if len(wmsg) != 3:
         raise WampProtocolError("invalid message length %d for WAMP Subscribe message" % len(wmsg))

      ## subscribeid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'subscribeid' in WAMP Subscription message" % type(wmsg[1]))

      subscribeid = parse_wamp_callid(wmsg[1])
      if subscribeid is None:
         raise WampProtocolError("invalid value '%s' for 'subscribeid' in WAMP Subscription message" % wmsg[1])

      ## subscriptionid
      ##
      if type(wmsg[2]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'subscriptionid' in WAMP Subscription message" % type(wmsg[2]))

      subscriptionid = parse_wamp_callid(wmsg[2])
      if subscriptionid is None:
         raise WampProtocolError("invalid value '%s' for 'subscriptionid' in WAMP Subscription message" % wmsg[2])

      obj = Klass(subscribeid, subscriptionid)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      return [Subscription.MESSAGE_TYPE, self.subscribeid, self.subscriptionid]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Subscription Message (subscribeid = '%s', subscriptionid = '%s')" % (self.subscribeid, self.subscriptionid)

class SubscribeError(Error):
   """
   A WAMP Subscribe-Error message.
   """

   MESSAGE_TYPE = 104
   """
   The WAMP message code for this type of message.
   """

class Unsubscribe(Message):
   """
   A WAMP Unsubscribe message.
   """

   MESSAGE_TYPE = 4
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, topic, match = Subscribe.MATCH_EXACT):
      """
      Message constructor.

      :param topic: The WAMP or application URI of the PubSub topic to unsubscribe from.
      :type topic: str
      :param match: The topic matching method effective for the subscription to unsubscribe from.
      :type match: int
      """
      Message.__init__(self)
      self.topic = topic
      self.match = match

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Unsubscribe.MESSAGE_TYPE)

      if len(wmsg) not in (2, 3):
         raise WampProtocolError("invalid message length %d for WAMP Unsubscribe message" % len(wmsg))

      ## topic
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for topic in WAMP Unsubscribe message" % type(wmsg[1]))

      topic = parse_wamp_uri(wmsg[1])
      if topic is None:
         raise WampProtocolError("invalid URI '%s' for topic in WAMP Unsubscribe message" % wmsg[1])

      ## options
      ##
      match = Subscribe.MATCH_EXACT

      if len(wmsg) == 3:
         options = wmsg[2]

         if type(options) != dict:
            raise WampProtocolError("invalid type %s for options in WAMP Unsubscribe message" % type(options))

         for k in options.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in options in WAMP Unsubscribe message" % type(k))

         if options.has_key('match'):

            option_match = options['match']
            if type(option_match) != int:
               raise WampProtocolError("invalid type %s for 'match' option in WAMP Unsubscribe message" % type(option_match))

            if option_match not in [Subscribe.MATCH_EXACT, Subscribe.MATCH_PREFIX, Subscribe.MATCH_WILDCARD]:
               raise WampProtocolError("invalid value %d for 'match' option in WAMP Unsubscribe message" % option_match)

            match = option_match

      obj = Klass(topic, match)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      options = {}

      if self.match != Subscribe.MATCH_EXACT:
         options['match'] = self.match

      if len(options):
         return [Unsubscribe.MESSAGE_TYPE, self.topic, options]
      else:
         return [Unsubscribe.MESSAGE_TYPE, self.topic]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Unsubscribe Message (topic = '%s', match = %s)" % (self.topic, Subscribe.MATCH_DESC.get(self.match))

class Publish(Message):
   """
   A WAMP Publish message.
   """

   MESSAGE_TYPE = 5
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, topic, event, excludeMe = None, exclude = None, eligible = None, discloseMe = None):
      """
      Message constructor.

      :param topic: The WAMP or application URI of the PubSub topic the event should be published to.
      :type topic: str
      :param event: Arbitrary application event payload (must be serializable using the serializer in use).
      :type event: any
      :param excludeMe: If True, exclude the publisher from receiving the event, even if he is subscribed (and eligible).
      :type excludeMe: bool
      :param exclude: List of WAMP session IDs to exclude from receiving this event.
      :type exclude: list
      :param eligible: List of WAMP session IDs eligible to receive this event.
      :type eligible: list
      :param discloseMe: If True, request to disclose the publisher of this event to subscribers.
      :type discloseMe: bool
      """
      Message.__init__(self)
      self.topic = topic
      self.event = event
      self.excludeMe = excludeMe
      self.exclude = exclude
      self.eligible = eligible
      self.discloseMe = discloseMe

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Publish.MESSAGE_TYPE)

      if len(wmsg) not in (3, 4):
         raise WampProtocolError("invalid message length %d for WAMP Publish message" % len(wmsg))

      ## topic
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for topic in WAMP Publish message" % type(wmsg[1]))

      topic = parse_wamp_uri(wmsg[1])
      if topic is None:
         raise WampProtocolError("invalid URI '%s' for topic in WAMP Publish message" % wmsg[1])

      ## event
      ##
      event = wmsg[2]

      ## options
      ##
      excludeMe = None
      exclude = None
      eligible = None
      discloseMe = None

      if len(wmsg) == 4:
         options = wmsg[3]

         if type(options) != dict:
            raise WampProtocolError("invalid type %s for options in WAMP Publish message" % type(options))

         for k in options.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in options in WAMP Publish message" % type(k))

         if options.has_key('excludeme'):

            option_excludeMe = options['excludeme']
            if type(option_excludeMe) != bool:
               raise WampProtocolError("invalid type %s for 'excludeme' option in WAMP Publish message" % type(option_excludeMe))

            excludeMe = option_excludeMe

         if options.has_key('exclude'):

            option_exclude = options['exclude']
            if type(option_exclude) != list:
               raise WampProtocolError("invalid type %s for 'exclude' option in WAMP Publish message" % type(option_exclude))

            for sessionId in option_exclude:
               if type(sessionId) not in (str, unicode):
                  raise WampProtocolError("invalid type %s for value in 'exclude' option in WAMP Publish message" % type(sessionId))

            exclude = option_exclude

         if options.has_key('eligible'):

            option_eligible = options['eligible']
            if type(option_eligible) != list:
               raise WampProtocolError("invalid type %s for 'eligible' option in WAMP Publish message" % type(option_eligible))

            for sessionId in option_eligible:
               if type(sessionId) not in (str, unicode):
                  raise WampProtocolError("invalid type %s for value in 'eligible' option in WAMP Publish message" % type(sessionId))

            eligible = option_eligible

         if options.has_key('discloseme'):

            option_discloseMe = options['discloseme']
            if type(option_discloseMe) != bool:
               raise WampProtocolError("invalid type %s for 'discloseme' option in WAMP Publish message" % type(option_identifyMe))

            discloseMe = option_discloseMe

      obj = Klass(topic, event, excludeMe, exclude, eligible, discloseMe)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      options = {}

      if self.excludeMe is not None:
         options['excludeme'] = self.excludeMe
      if self.exclude is not None:
         options['exclude'] = self.exclude
      if self.eligible is not None:
         options['eligible'] = self.eligible
      if self.discloseMe is not None:
         options['discloseme'] = self.discloseMe

      if len(options):
         return [Publish.MESSAGE_TYPE, self.topic, self.event, options]
      else:
         return [Publish.MESSAGE_TYPE, self.topic, self.event]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Publish Message (topic = '%s', event = %s, excludeMe = %s, exclude = %s, eligible = %s, discloseMe = %s)" % (self.topic, self.event, self.excludeMe, self.exclude, self.eligible, self.discloseMe)

class Event(Message):
   """
   A WAMP Event message.
   """

   MESSAGE_TYPE = 6
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, subscriptionid, topic, event = None, publisher = None):
      """
      Message constructor.

      :param topic: The WAMP or application URI of the PubSub topic the event was published to.
      :type topic: str
      :param event: Arbitrary application event payload (must be serializable using the serializer in use).
      :type event: any
      :param publisher: If present, the WAMP session ID of the publisher of this event.
      :type publisher: str
      """
      Message.__init__(self)
      self.subscriptionid = subscriptionid
      self.topic = topic
      self.event = event
      self.publisher = publisher

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Event.MESSAGE_TYPE)

      if len(wmsg) not in (3, 4, 5):
         raise WampProtocolError("invalid message length %d for WAMP Event message" % len(wmsg))

      ## subscriptionid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'subscriptionid' in WAMP Event message" % type(wmsg[1]))

      subscriptionid = parse_wamp_callid(wmsg[1])
      if subscriptionid is None:
         raise WampProtocolError("invalid value '%s' for 'subscriptionid' in WAMP Event message" % wmsg[1])

      ## topic
      ##
      if type(wmsg[2]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for topic in WAMP Event message" % type(wmsg[2]))

      topic = parse_wamp_uri(wmsg[2])
      if topic is None:
         raise WampProtocolError("invalid URI '%s' for topic in WAMP Event message" % wmsg[2])

      ## event
      ##
      event = None
      if len(wmsg) > 3:
         event = wmsg[3]

      ## details
      ##
      publisher = None

      if len(wmsg) > 4:
         details = wmsg[4]

         if type(details) != dict:
            raise WampProtocolError("invalid type %s for 'details' in WAMP Event message" % type(details))

         for k in details.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in 'details' in WAMP Event message" % type(k))

         if details.has_key('publisher'):

            detail_publisher = details['publisher']
            if type(detail_publisher) not in (str, unicode):
               raise WampProtocolError("invalid type %s for 'publisher' detail in WAMP Event message" % type(detail_publisher))

            publisher = detail_publisher

      obj = Klass(subscriptionid, topic, event, publisher)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      details = {}

      if self.publisher is not None:
         details['publisher'] = self.publisher

      if len(details):
         return [Event.MESSAGE_TYPE, self.topic, self.event, details]
      else:
         if self.event is not None:
            return [Event.MESSAGE_TYPE, self.subscriptionid, self.topic, self.event]
         else:
            return [Event.MESSAGE_TYPE, self.subscriptionid, self.topic]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Publish Message (subscriptionid = '%s', topic = '%s', event = %s, publisher = %s)" % (self.subscriptionid, self.topic, self.event, self.publisher)

class MetaEvent(Message):
   """
   A WAMP Meta-Event message.
   """

   MESSAGE_TYPE = 7
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, topic, metatopic, metaevent = None):
      """
      Message constructor.

      :param topic: The WAMP or application URI of the PubSub topic the metaevent is published for.
      :type topic: str
      :param metatopic: The WAMP URI of the metatopic of the metaevent.
      :type metatopic: str
      :param metaevent: WAMP metaevent payload.
      :type metaevent: any
      """
      Message.__init__(self)
      self.topic = topic
      self.metatopic = metatopic
      self.metaevent = metaevent

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == MetaEvent.MESSAGE_TYPE)

      if len(wmsg) not in (3, 4):
         raise WampProtocolError("invalid message length %d for WAMP Meta-Event message" % len(wmsg))

      ## topic
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'topic' in WAMP Meta-Event message" % type(wmsg[1]))

      topic = parse_wamp_uri(wmsg[1])
      if topic is None:
         raise WampProtocolError("invalid URI '%s' for 'topic' in WAMP Meta-Event message" % wmsg[1])

      ## metatopic
      ##
      if type(wmsg[2]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'metatopic' in WAMP Meta-Event message" % type(wmsg[2]))

      metatopic = parse_wamp_uri(wmsg[2])
      if metatopic is None:
         raise WampProtocolError("invalid URI '%s' for 'metatopic' in WAMP Meta-Event message" % wmsg[2])

      ## metaevent
      ##
      metaevent = None
      if len(wmsg) == 4:
         metaevent = wmsg[3]

      obj = Klass(topic, metatopic, metaevent)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      if self.metaevent is not None:
         return [MetaEvent.MESSAGE_TYPE, self.topic, self.metatopic, self.metaevent]
      else:
         return [MetaEvent.MESSAGE_TYPE, self.topic, self.metatopic]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Meta-Event Message (topic = '%s', metatopic = '%s', metaevent = %s)" % (self.topic, self.metatopic, self.metaevent)

class Provide(Message):
   """
   A WAMP Provide message.
   """

   MESSAGE_TYPE = 8
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, endpoint, pkeys = None):
      """
      Message constructor.

      :param endpoint: The WAMP or application URI of the RPC endpoint provided.
      :type endpoint: str
      :param pkeys: The endpoint can work for this list of application partition keys.
      :type pkeys: list
      """
      Message.__init__(self)
      self.endpoint = endpoint
      self.pkeys = pkeys

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Provide.MESSAGE_TYPE)

      if len(wmsg) not in (2, 3):
         raise WampProtocolError("invalid message length %d for WAMP Provide message" % len(wmsg))

      ## topic
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'endpoint' in WAMP Provide message" % type(wmsg[1]))

      endpoint = parse_wamp_uri(wmsg[1])
      if endpoint is None:
         raise WampProtocolError("invalid URI '%s' for 'endpoint' in WAMP Provide message" % wmsg[1])

      ## options
      ##
      pkeys = None

      if len(wmsg) == 3:
         options = wmsg[2]

         if type(options) != dict:
            raise WampProtocolError("invalid type %s for 'options' in WAMP Provide message" % type(options))

         for k in options.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in 'options' in WAMP Provide message" % type(k))

         if options.has_key('pkeys'):

            option_pkeys = options['pkeys']
            if type(option_pkeys) != list:
               raise WampProtocolError("invalid type %s for 'pkeys' option in WAMP Provide message" % type(option_pkeys))

            for pk in option_pkeys:
               if type(pk) not in (str, unicode):
                  raise WampProtocolError("invalid type for value '%s' in 'pkeys' option in WAMP Provide message" % type(pk))

            pkeys = option_pkeys

      obj = Klass(endpoint, pkeys)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      options = {}

      if self.pkeys is not None:
         options['pkeys'] = self.pkeys

      if len(options):
         return [Provide.MESSAGE_TYPE, self.endpoint, options]
      else:
         return [Provide.MESSAGE_TYPE, self.endpoint]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Provide Message (endpoint = '%s', pkeys = %s)" % (self.endpoint, self.pkeys)

class Unprovide(Message):
   """
   A WAMP Unprovide message.
   """

   MESSAGE_TYPE = 9
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, endpoint, pkeys = None):
      """
      Message constructor.

      :param endpoint: The WAMP or application URI of the RPC endpoint unprovided.
      :type endpoint: str
      :param pkeys: The endpoint is unprovided to work for this list of application partition keys.
      :type pkeys: list
      """
      Message.__init__(self)
      self.endpoint = endpoint
      self.pkeys = pkeys

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Unprovide.MESSAGE_TYPE)

      if len(wmsg) not in (2, 3):
         raise WampProtocolError("invalid message length %d for WAMP Unprovide message" % len(wmsg))

      ## topic
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'endpoint' in WAMP Unprovide message" % type(wmsg[1]))

      endpoint = parse_wamp_uri(wmsg[1])
      if endpoint is None:
         raise WampProtocolError("invalid URI '%s' for 'endpoint' in WAMP Unprovide message" % wmsg[1])

      ## options
      ##
      pkeys = None

      if len(wmsg) == 3:
         options = wmsg[2]

         if type(options) != dict:
            raise WampProtocolError("invalid type %s for 'options' in WAMP Unprovide message" % type(options))

         for k in options.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in 'options' in WAMP Unprovide message" % type(k))

         if options.has_key('pkeys'):

            option_pkeys = options['pkeys']
            if type(option_pkeys) != list:
               raise WampProtocolError("invalid type %s for 'pkeys' option in WAMP Unprovide message" % type(option_pkeys))

            for pk in option_pkeys:
               if type(pk) not in (str, unicode):
                  raise WampProtocolError("invalid type for value '%s' in 'pkeys' option in WAMP Unprovide message" % type(pk))

            pkeys = option_pkeys

      obj = Klass(endpoint, pkeys)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      options = {}

      if self.pkeys is not None:
         options['pkeys'] = self.pkeys

      if len(options):
         return [Unprovide.MESSAGE_TYPE, self.endpoint, options]
      else:
         return [Unprovide.MESSAGE_TYPE, self.endpoint]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Unprovide Message (endpoint = '%s', pkeys = %s)" % (self.endpoint, self.pkeys)

class Call(Message):
   """
   A WAMP Call message.
   """

   MESSAGE_TYPE = 10
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, callid, endpoint, args = [], sessionid = None, timeout = None):
      """
      Message constructor.

      :param callid: The WAMP call ID of the original call.
      :type callid: str
      :param endpoint: The WAMP or application URI of the RPC endpoint to be called.
      :type endpoint: str
      :param args: The (positional) arguments to be supplied for the parameters to the called endpoint.
      :type args: list
      :param sessionid: If present, restrict the callee to the given WAMP session ID.
      :type sessionid: str
      :param timeout: If present, let the callee automatically cancel the call after this ms.
      :type timeout: int
      """
      Message.__init__(self)
      self.callid = callid
      self.endpoint = endpoint
      self.args = args
      self.sessionid = sessionid
      self.timeout = timeout

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == Call.MESSAGE_TYPE)

      if len(wmsg) not in (3, 4, 5):
         raise WampProtocolError("invalid message length %d for WAMP Call message" % len(wmsg))

      ## callid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'callid' in WAMP Call message" % type(wmsg[1]))

      callid = parse_wamp_callid(wmsg[1])
      if callid is None:
         raise WampProtocolError("invalid value '%s' for 'callid' in WAMP Call message" % wmsg[1])

      ## endpoint
      ##
      if type(wmsg[2]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'endpoint' in WAMP Call message" % type(wmsg[2]))

      endpoint = parse_wamp_uri(wmsg[2])
      if endpoint is None:
         raise WampProtocolError("invalid value '%s' for 'endpoint' in WAMP Call message" % wmsg[2])

      ## args
      ##
      args = []
      if len(wmsg) > 3:
         if type(wmsg[3]) != list:
            raise WampProtocolError("invalid type %s for 'arguments' in WAMP Call message" % type(wmsg[3]))
         args = wmsg[3]

      ## options
      ##
      sessionid = None
      timeout = None

      if len(wmsg) == 5:
         options = wmsg[4]

         if type(options) != dict:
            raise WampProtocolError("invalid type %s for 'options' in WAMP Call message" % type(options))

         for k in options.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in 'options' in WAMP Call message" % type(k))

         if options.has_key('session'):

            option_sessionid = options['session']
            if type(option_sessionid) not in (str, unicode):
               raise WampProtocolError("invalid type %s for 'session' option in WAMP Call message" % type(option_session))

            option_sessionid = parse_wamp_session(option_sessionid)
            if option_sessionid is None:
               raise WampProtocolError("invalid value %s for 'session' option in WAMP Call message" % options['session'])

            sessionid = option_sessionid

         if options.has_key('timeout'):

            option_timeout = options['timeout']
            if type(option_timeout) != int:
               raise WampProtocolError("invalid type %s for 'timeout' option in WAMP Call message" % type(option_timeout))

            if option_timeout < 0:
               raise WampProtocolError("invalid value %d for 'timeout' option in WAMP Call message" % option_timeout)

            timeout = option_timeout

      obj = Klass(callid, endpoint, args, sessionid = sessionid, timeout = timeout)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      options = {}

      if self.timeout is not None:
         options['timeout'] = self.timeout

      if self.sessionid is not None:
         options['session'] = self.sessionid

      if len(options):
         return [Call.MESSAGE_TYPE, self.callid, self.endpoint, self.args, options]
      else:
         if len(self.args) > 0:
            return [Call.MESSAGE_TYPE, self.callid, self.endpoint, self.args]
         else:
            return [Call.MESSAGE_TYPE, self.callid, self.endpoint]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Call Message (callid = '%s', endpoint = '%s', args = %s, sessionid = '%s', timeout = %s)" % (self.callid, self.endpoint, self.args, self.sessionid, self.timeout)

class CancelCall(Message):
   """
   A WAMP Cancel-Call message.
   """

   MESSAGE_TYPE = 11
   """
   The WAMP message code for this type of message.
   """

   CANCEL_SKIP = 1
   CANCEL_ABORT = 2
   CANCEL_KILL = 3

   CANCEL_DESC = {
      CANCEL_SKIP: 'skip',
      CANCEL_ABORT: 'abort',
      CANCEL_KILL: 'kill'
   }

   def __init__(self, callid, mode = None):
      """
      Message constructor.

      :param callid: The WAMP call ID of the original call to cancel.
      :type callid: str
      :param mode: Specifies how to cancel the call (skip, abort or kill).
      :type mode: int
      """
      Message.__init__(self)
      self.callid = callid
      self.mode = mode

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == CancelCall.MESSAGE_TYPE)

      if len(wmsg) not in (2, 3):
         raise WampProtocolError("invalid message length %d for WAMP Cancel-Call message" % len(wmsg))

      ## callid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'callid' in WAMP Cancel-Call message" % type(wmsg[1]))

      callid = parse_wamp_callid(wmsg[1])
      if callid is None:
         raise WampProtocolError("invalid URI '%s' for 'callid' in WAMP Cancel-Call message" % wmsg[1])

      ## options
      ##
      mode = None

      if len(wmsg) == 3:
         options = wmsg[2]

         if type(options) != dict:
            raise WampProtocolError("invalid type %s for 'options' in WAMP Cancel-Call message" % type(options))

         for k in options.keys():
            if type(k) not in (str, unicode):
               raise WampProtocolError("invalid type %s for key in 'options' in WAMP Cancel-Call message" % type(k))

         if options.has_key('mode'):

            option_mode = options['mode']
            if type(option_mode) != int:
               raise WampProtocolError("invalid type %s for 'mode' option in WAMP Cancel-Call message" % type(option_mode))

            if option_moption_modeatch not in [CancelCall.CANCEL_SKIP, CancelCall.CANCEL_ABORT, CancelCall.CANCEL_KILL]:
               raise WampProtocolError("invalid value %d for 'mode' option in WAMP Cancel-Call message" % option_mode)

            mode = option_mode

      obj = Klass(callid, mode = mode)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      options = {}

      if self.mode is not None:
         options['mode'] = self.mode

      if len(options):
         return [CancelCall.MESSAGE_TYPE, self.callid, options]
      else:
         return [CancelCall.MESSAGE_TYPE, self.callid]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Cancel-Call Message (callid = '%s', mode = %s)" % (self.callid, CancelCall.CANCEL_DESC.get(self.mode))

class CallProgress(Message):
   """
   A WAMP Call-Progress message.
   """

   MESSAGE_TYPE = 12
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, callid, progress = None):
      """
      Message constructor.

      :param callid: The WAMP call ID of the original call this result is for.
      :type callid: str
      :param progress: Arbitrary application progress (must be serializable using the serializer in use).
      :type progress: any
      """
      Message.__init__(self)
      self.callid = callid
      self.progress = progress

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == CallProgress.MESSAGE_TYPE)

      if len(wmsg) not in (2, 3):
         raise WampProtocolError("invalid message length %d for WAMP Call-Progress message" % len(wmsg))

      ## callid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'callid' in WAMP Call-Progress message" % type(wmsg[1]))

      callid = parse_wamp_callid(wmsg[1])
      if callid is None:
         raise WampProtocolError("invalid value '%s' for 'callid' in WAMP Call-Progress message" % wmsg[1])

      ## result
      ##
      progress = None
      if len(wmsg) > 2:
         progress = wmsg[2]

      obj = Klass(callid, progress)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      if self.progress is not None:
         return [CallProgress.MESSAGE_TYPE, self.callid, self.progress]
      else:
         return [CallProgress.MESSAGE_TYPE, self.callid]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Call-Progress Message (callid = '%s', progress = %s)" % (self.callid, self.progress)

class CallResult(Message):
   """
   A WAMP Call-Result message.
   """

   MESSAGE_TYPE = 13
   """
   The WAMP message code for this type of message.
   """

   def __init__(self, callid, result = None):
      """
      Message constructor.

      :param callid: The WAMP call ID of the original call this result is for.
      :type callid: str
      :param result: Arbitrary application result (must be serializable using the serializer in use).
      :type result: any
      """
      Message.__init__(self)
      self.callid = callid
      self.result = result

   @classmethod
   def parse(Klass, wmsg):
      """
      Verifies and parses an unserialized raw message into an actual WAMP message instance.

      :param wmsg: The unserialized raw message.
      :type wmsg: list
      :returns obj -- An instance of this class.
      """
      ## this should already be verified by WampSerializer.unserialize
      ##
      assert(len(wmsg) > 0 and wmsg[0] == CallResult.MESSAGE_TYPE)

      if len(wmsg) not in (2, 3):
         raise WampProtocolError("invalid message length %d for WAMP Call-Result message" % len(wmsg))

      ## callid
      ##
      if type(wmsg[1]) not in (str, unicode):
         raise WampProtocolError("invalid type %s for 'callid' in WAMP Call-Result message" % type(wmsg[1]))

      callid = parse_wamp_callid(wmsg[1])
      if callid is None:
         raise WampProtocolError("invalid value '%s' for 'callid' in WAMP Call-Result message" % wmsg[1])

      ## result
      ##
      result = None
      if len(wmsg) > 2:
         result = wmsg[2]

      obj = Klass(callid, result)

      return obj

   def marshal(self):
      """
      Marshal this object into a raw message for subsequent serialization to bytes.
      """
      if self.result is not None:
         return [CallResult.MESSAGE_TYPE, self.callid, self.result]
      else:
         return [CallResult.MESSAGE_TYPE, self.callid]

   def __str__(self):
      """
      Returns text representation of this instance.

      :returns str -- Human readable representation (eg for logging or debugging purposes).
      """
      return "WAMP Call-Result Message (callid = '%s', result = %s)" % (self.callid, self.result)

class CallError(Error):
   """
   A WAMP Call-Error message.
   """

   MESSAGE_TYPE = 14
   """
   The WAMP message code for this type of message.
   """

redpajama_set_name: RedPajamaGithub


It is commonly believed that on the Day of Judgment God Almighty will call the people by his/her mothers' name. Is it authentic?
I heard in one lecture about "signs" of the Last Day (qiyamat) that "authentic signs are only two and both of them have already been fulfilled. Third one is about Gog and Magog, yet to be fulfilled. Others all signs we usually hear, are not authentic. My question is that I also heard that at the time of qiyamat "no Muslim would be alive and Qur'an would be no more preserved in this world" Is that true? I mean is it possible that qiyamat could come even when good people and Muslims people would be living in the world? Because by that saying, many people say that "qiyamat will not come at the moment because there are still many Muslims (good one) living here and Qur'an is still among us.
My concern is what will be criteria to ask question to the people of different mental level. For example villagers compared to highly qualified ones. I have noticed that many people in villages and especially women in villages are involved in polytheism and mostly they are just following the traditional acts of their parents and/or husbands. They even don't have basic concept of Islam. Going to visit saints, graves and much more. So how will be those people treated?


text:
Sedgeford was a railway station which served the settlement of Sedgeford in Norfolk, England. Opened by the West Norfolk Junction Railway in 1866, passenger services ceased with the line in 1952.

History
The construction of the West Norfolk Junction Railway was prompted by the success of the Lynn and Hunstanton Railway which had opened in 1862 to link King's Lynn with the seaside town of Hunstanton. The West Norfolk opened in 1866 at the start of a major financial crisis triggered by the collapse of Overend Gurney Bank; the year also saw the outbreak of a "cattle plague" in North Norfolk which impacted on the cattle receipts on the line. The West Norfolk was absorbed into the Lynn and Hunstanton Railway in 1872 which in turn was acquired by the Great Eastern Railway in 1890. The line eventually closed to passengers in 1952, a consequence of rising costs and falling passenger numbers, aggravated by the inconvenient siting of stations. Up to the end of its passenger services, the line was one of the last where one could travel in gas-lit clerestory coaches hauled by Victorian locomotives.

A freight service continued to operate until 1964, though it was cut back to Heacham/Burnham Market after the North Sea flood of 1953 which badly damaged the section between Holkham and Wells, damage which British Railways judged not worth repairing.

Sedgeford station was the first station after Heacham on the single-track West Norfolk Junction Railway. It was a small station located in a rural area, equipped with a single platform on the down side, built to smaller dimensions to other stations on the Lynn and Hunstanton Railway, and without a stationmaster's residence. Very basic goods facilities were provided in the shape of a single carriage siding on the down side. The station's staff amounted to two persons, reduced to one in the final years. Traffic on the line was largely agricultural, consisting of corn, sugar beet, cattle and agricultural machinery. A level crossing lay to the east of the platform.

Present day
The station buildings have been particularly well preserved as a private residence, complete with the station sign and Great Eastern Railway notices. The level crossing gate remains with a notice reading "Failure to shut the gate - fine 40/-".

See also
 List of closed railway stations in Norfolk
 Sedgeford station on navigable 1946 O. S. map

References

Disused railway stations in Norfolk
Former Great Eastern Railway stations
Railway stations in Great Britain opened in 1866
Railway stations in Great Britain closed in 1952
1866 establishments in England

redpajama_set_name: RedPajamaWikipedia


text:
Fauré: Dolly Suite Op.56…
Fauré: Dolly Suite Op.56 No.2 "Mi-a-ou" - symphonic wind dectet/bass quantity
Fauré: Dolly Suite Op.56 No.2 "Mi-a-ou" – symphonic wind dectet/bass
SKU: RTM001 Categories: Chamber Ensemble, Woodwind, Woodwind Ensemble Tags: Clarinet, dectet, Horn, Oboe, Wind Quintet
Store: RayThompsonMusic
The Dolly Suite, Op. 56, is a collection of pieces for piano four-hands by Gabriel Fauré. It consists of short pieces written or revised between 1893 and 1896, to mark the birthdays and other events in the life of the daughter of the composer's mistress.
An orchestral version of the suite was scored in 1906 by Henri Rabaud, and has, like the original piano duet version, received several recordings. The best-known section of the suite, the Berceuse, has been arranged for several combinations of instruments. In Britain it became famous as the play-out tune to Listen with Mother.
The suite, consisting of six short pieces, each with its own title: Berceuse, Mi-a-ou, Le jardin de Dolly, Kitty-valse, Tendresse and Le pas espagnol. The complete suite takes about fifteen minutes to perform.
This is my arrangement of movement.2 "Mi-a-ou"
It is arranged for double wind quintet and bass
Allegro vivo. "Mi-a-ou" was written for Dolly's second birthday in June 1894. The title does not refer to a pet cat, as has often been supposed, but to Dolly's attempts to pronounce the name of her elder brother Raoul, who later became one of Fauré's favourite pupils.The young Dolly called her brother Messieu Aoul, which Fauré took as the original title for the piece. In his finished manuscript the title is shortened to "Miaou" (without hyphens).The Fauré scholar Robert Orledge writes that the title "Mi-a-ou", like that of the "Kitty-valse" later in the suite, is the responsibility of Fauré's publisher, Julien Hamelle.[
Chamber Ensemble, Wind Ensemble, Wind Quintet
Be the first to review "Fauré: Dolly Suite Op.56 No.2 "Mi-a-ou" – symphonic wind dectet/bass" Cancel reply
Debussy: Children's Corner Mvt.5 The Little Shepherd – clarinet trio
Bach: Sinfonia (Three part Inventions) Nos.1,2 & 3 arr.clarinet trio
Beethoven: (as adapted Seiss): Contre-Tanze (Country Dance) No.1 – wind quintet
Scott Joplin: "The Cascades" – clarinet trio
Beethoven: Symphony No.7 Op.92 Mvt.III Presto – symphonic wind and bass

redpajama_set_name: RedPajamaCommonCrawl


text:
Cephalophyllum curtophyllum är en isörtsväxtart som först beskrevs av L. Bol., och fick sitt nu gällande namn av Schwant. Cephalophyllum curtophyllum ingår i släktet Cephalophyllum och familjen isörtsväxter. Inga underarter finns listade i Catalogue of Life.

Källor

Isörtsväxter
curtophyllum


text:
Q: Scope of variable in DOJO when created from within function In a DOJO widget there is code in the postCreate and destroy method to create/start and stop a timer like you can see below. Depending on the value in a drop down box the timer is started or stopped. This works fine so far.
postCreate: function() {

    var deferred = this.own(<...some action...>)[0];
    deferred.then(
        lang.hitch(this, function(result) {

            this.t = new dojox.timing.Timer(result.autoRefreshInterval * 1000);
            this.t.onTick = lang.hitch(this, function() {
                console.info("get new data");
            });
            this.t.onStart = function() {
                console.info("starting timer");
            };
            this.t.onStop = function() {
                console.info("timer stopped");
            };

        })
    );

    this.selectAutoRefresh.on("change", lang.hitch(this, function(value) {
        if (value == "Automatic") {
            this.t.start();
        } else {
            this.t.stop();
        }
    }));
},

When leaving the page the timer is still active so I want to stop it when I leave the page using DOJOs destroy() method.
destroy: function() {
    this.t.stop();
},

This however throws a this.t.stop is not a function exception. It seems like this.t is not created in the context of the widget although I use lang.hitch(this...
What am I missing here?

A: I solved that by just renaming the variable t to refreshTimer. Maybe t is some kind of reserved variable in Dojo?

redpajama_set_name: RedPajamaStackExchange


text:
The people who inspired us this year
This is the time of year when we search for inspiration. A new year is close and with it comes a feeling of wanting to be better, to improve in some way, to take full advantage of the fresh set of days that stretches ahead of us.
To help us find a better course, we look to people we admire. We mine their stories for wisdom and insight. In doing so we find new ideas and ways forward.
Below are just a few of the stories we told this year, but we believe they're among the most powerful. They're full of people living extraordinary lives and doing exceptional things.
From Paul Daugherty's story on Lauren Hill:
"No one but those doing the dying knows what that's like. All of us come with an expiration date. Few of us have a timetable as accurate as Lauren's. None of us has any idea how we might react, handed her circumstances.
She's a model, though. If you believe each of us is here for a reason, you'll find no better evidence than this 19-year-old, basketball-playing young woman from Lawrenceburg."
From Paul Daugherty's story on Leah Still:
"Every parent who has ever known the helpless feeling of dealing with a child's terrible sickness is offering a bowed head and a bended knee. Everyone else has a reason to feel compassionate, and fortunate.
Leah Still has become Our Child."
From Rachel Richardson:
After the murder of her son, Justin Back, Waynesville Township mom Sandy Cates has worked to transform her grief into action. She's launched the "Pay it Forward, Justin-style" campaign to inspire random acts of kindness and is working to see Justin's Law, a bill which strengthens prison sentences for convicted killers, passed in Ohio.
Adam and Kara Ayers are enjoying their newly expanded family with the adoption of their son, Eli. The couple, both of whom have osteogenesis imperfecta, a form of dwarfism, and who use wheelchairs, spent more than a year adopting Eli, who has achondroplasia, another form of dwarfism.
Despite Chinese laws that prohibit discrimination on the basis of disability, Chinese people with disabilities still face prejudice and limited opportunities in employment, education and access to health care and government services.
"Specific to dwarfism, there is an additional cultural taboo that (Eli) would likely be mocked in the streets and definitely not allowed to go to school or get married," Kara said. "His only option for survival would be begging on the street."
Abandoned in a public square when he was 6 months old, Eli, now 7, had been on the adoption list for just two years when the Ayerses found his listing in a Facebook group dedicated to finding adoptive homes for children with dwarfism.
From Mike Dyer:
Woodward volleyball coach Rochelle Adams continued to coach her team despite a cancer diagnosis.
Senior Sharnae Newman said Adams will do anything for the team.
"She goes above and beyond for us," Newman said. "…She is really a second mother to us."
Adams, who is also an assistant cheerleading coach the school, could tell her journey impacted the players. She was just happy to be someone who her players could confide in with concerns or issues at school or at home.
"I had no chance but to be strong and to continue what I did for as long as I could," Adams said.
Brayden Thornbury, a Little Miami football player who died in car accident in September, inspired a community and a region with his selfless nature.
From Karen Bells' column about Brayden:
"One young man, a year older than Brayden, said, 'I always wanted to be more like him. He always made me want to be better.' Another of Brayden's classmates and teammates, through his tears, shared stories both funny and sweet. Always one to be a class clown, he unwittingly brought a ripple of comic relief through the crowd when he said, 'I'm sorry for cussing, but I'm just going to say it – Brayden being the way he is makes me want to not be an asshole.' And then, like many of the players who spoke that evening, he took a knee and touched the 50-yard line for his lost friend."
Western Hills football coach Paul Jenne continued to help his players despite cancer.
When the 49-year-old learned he was diagnosed with colorectal cancer in March, he became increasingly concerned not only for his family and loved ones but the relationships he's had with his players for the past three to four years.
"He puts in long hours," former Western Hills athletic director Jim Sherard said. "People don't have an idea - he is the guy who doesn't do a lot of talking. He does a lot of extra things people don't know about."
From Amanda Van Benschoten:
Opal Evans' first adventure was a big one: at the age of 7, the daughter of a blacksmith from Muse's Mill, Kentucky boarded a train with her parents and two younger brothers for a 90-mile trip to Latonia, where her father had found work.
The year was 1916, and the train was so new that the tracks were still being laid as the engine chugged its way north, Evans recalls.
Perhaps it was that trip which gave Opal a taste for finding out what the world had to offer a small-town girl. Or maybe she was born to it, along with an indomitable personality and sparkling brown eyes.
In any case, that small-town girl would go on to have a lifetime full of wonderful adventures, from flying to every continent in the world, to hitching up the Airstream trailer and taking off to see most of North America.
"I've had a wonderful life," said Evans, who turned 105 years old this year. "You don't realize what a beautiful world we live in until you get out and see it."
From Terry DeMio:
Jason Merrick, chairman of Northern Kentucky People Advocating Recovery (NKY PAR), led the region's fight against heroin by volunteering countless hours to organize and hand out naloxone kits. Naloxone is the life-saving pharmaceutical that can restore breathing in heroin overdose victims. More than 200 kits have been handed out at free clinics, and five people have been saved, including a 15-year-old boy from Covington.
Merrick also inspired a PAR Ohio chapter because, he said, those with addiction disease, and their families and loved ones, need help in southwest Ohio.
He has also been to Frankfort to push for heroin-related legislation.
From Janelle Gelfand:
Isaac Selya, 28, founder of Queen City Chamber Opera, is a classically-trained conductor who saw an opportunity in Cincinnati to create a small opera company for chamber-sized productions. His company is one of four young opera start-ups now taking root in Cincinnati's cultural landscape.
"I didn't know that it was so fertile a ground for entrepreneurism when I arrived," Selya, a classical conductor, says.
Lured by the opera department at the University of Cincinnati College-Conservatory of Music (CCM), Selya came home to earn a doctorate in conducting. Once here, he realized the wealth of talent at CCM just waiting for a stage. Emerging opera singers are often found working at Whole Foods and Trader Joe's while singing bit parts at Cincinnati Opera in the summer.
"CCM is churning out lots and lots of highly qualified singers. Cincinnati Opera is a world-class company, but it's summer only. So singers take jobs at Whole Foods to pay the bills," he says. "I feel that I can take advantage of that by offering them a small company where they get to do principal roles."
From Julie Engebrecht:
University of Cincinnati DAAP professor Ryan Mulligan believes that his job as an artist is to help make the world a better place to live.
"I don't want to be alone in my studio making things that are just for me," he says. "Not that there's anything wrong with self-expression. But it's not my charge anymore."
This summer, Mulligan, of Blue Ash, pulled together more than 100 Walnut Hills and East Walnut Hills residents, students, former students, professional filmmakers, actors, dancers and friends to help him create 10 short films, which he showed to more than 300 neighbors during a movie night at an East Walnut Hills parking lot.
Mulligan believes that by meeting our neighbors, we'll create a stronger social fabric, a better world. Next, he wants to help do his part to help combat the problem of infant mortality in Cincinnati. He's working on a small pilot project with Cradle Cincinnati.
From Sharon Coolidge:
My best friend growing up loves to visit Cincinnati, partly because of its inclusive feeling. After taking over the City Hall beat in May I learned much of the reason for the inclusive feeling was because of Council's actions to make Cincinn
ati gay and lesbian friendly, a movement led by Councilman Chris Seelbach, the city's first openly gay councilman.
Seelbach came out when he was 18 and has been crusading for gay rights ever since.
Ten years ago Cincinnati was at the bottom of the Human Rights Campaign Equality Index. This year the city scored 100, with the organization's leaders unveiling the list here.
Since being elected in 2011, Seelbach has led votes to extend equal partner health benefits and to create a domestic partner registry. He helped bring a LGBT liaison to the police, fire and mayor's office. These efforts don't go unnoticed by people who want to move to Cincinnati or stay in Cincinnati or visit Cincinnati.
So, for that, I think Seelbach is an inspiration.
Which stories inspired you this year? Share them in the comments section along with why they touched you.


The first release (v1.1.0.0) in the development branch of openBVE was made available a few days ago, and now v1.1.1.0 has subsequently been released — the development branch includes support for full 3D cabs with animated objects, and mouse controlled camera rotation. v1.1.1.0 also introduces driver's head motion, which responds to acceleration and deceleration, as well as inertia.
Firstly, releases in the openBVE development branch are intended for developers who wish to expermiment with new features and offer feedback before these are eventually incorporated into the stable branch. Development releases may contain undetected issues, and features are subject to change, which means the development releases aren't entirely suitable for regular users and the less technically minded, however I strongly recommend that developers and advanced users take a look at the development releases. If you're interested in examining the new 3D cab support, you can head over to the » openBVE homepage « to download version 1.1.1.0, along with a demonstration 3D cab update for the 113-1000atccab train (look under Examples via the » Developing for openBVE « menu). Please also read the » Changelog « for a full list of alterations and new features.
Anyway, I've spent around a week working on a 3D cab for the new class 323 EMU and Cross-City South v1.4, and I'm really pleased with the results so far. I've uploaded a new YouTube video to briefly demonstrate the immersive nature of a 3D cab, the added realism, and some of the animated object possibilities — animated traction/brake controller, reverser and horn lever, working in-cab safety system indicators, simulated working headlights which give the effect of outside illumination (but see caveat below), along with working in-cab illumination. I think the potential of openBVE as a cab based simulator can now be truly realised, and speaking personally, this has forever changed the way I experience openBVE routes, and as long as photo-realism is maintained in new 3D cab environments, I'll likely not want to go back to 2D cabs now.
This latest video was originally intended to show some other things I've been working on, so you'll find many clips of the new 3D interior for the class 323, which includes seating, working television screens and lights, moving and streaking raindrop effects (inspired by the rain effects from Flight Unlimited 3), and ground illumination from the windows and pantograph sparking at night. The performance improvements which came with openBVE v1.0.7 also enabled me to capture some higher resolution video of Watford Junction to Rugby, of which many shots are included (and it has train sounds rather than my dreadful music this time 😉 ).
I'm also pleased to say that Cross-City South v1.4 now includes a full set of on-train conductor's announcements, with enormous thanks to voice recording artist Pete Kingwell » http://www.petekingwell.com «. Pete has also recorded a set of alternative Birmingham New Street station announcements, and we agreed that all these sounds could be released into the public domain along with the rest of the Cross-City South v1.4 files once released. Thanks must also go to Paul Sladen (maintainer of the Ubuntu version of openBVE) for intiating this aspect of the project as well. I'm glad to be able to remove another set of copyright files from the route now, while being able to add something new which has been missing from the Cross-City South route for years as well, and an example on-train announcement is included in the video.
I strongly recommend viewing this video in full screen due to some night time shots, in which some details might be hard to make out otherwise.
For the 323's 3D cab, I've opted for a combination of moderately complex 3D geometry combined with photo-realistic textures, some of which were easily adapted from the existing 2D panel images. Developing the new cab wasn't really more difficult than developing any other animated object, as that is exactly what the cab is — it just took longer as there are more animated parts. The most difficult tasks I found, were probably the gauges and needles, which needed quite a lot of experimentation before the results were right, partly because the 323's panel is sloped backwards rather than being vertical, meaning that correctly tilting the axis around which the animated needles rotate took a little while.
As an additional starting point for other train developers, here are the functions I'm using in the panel.animated file for the speedometer, main reservoir and brake cylinder needles, amongst other features, which I'm using.
Note: Some examples include two states, where one specifies an object illuminated by in-cab lighting, and the other specifies a non-emissive version of the object, shown when the power is cut, based on state of the ats31 plugin variable defined in the 323's panel2.cfg file (when used with Simon Gathercole's UKMUt.dll).
These two objects contain any non-animated portions of the cab, but one is a duplicate with emissive properties disabled, so in-cab lighting can be turned on and off according to the state of plugin variable ats31 in this case, which simulates the effect of the power being cut, or a cold and dark cab environment.
The gauge background and cover are included as part of the base 3D geometry of the cab itself, not as seperate objects. The value -3.678 in rotatexfunction rotates the needle to 0 mph on this speedometer (adjust for your own gauge as required, using ObjectViewer to check the results). Where the last value (0.0945) is concerned, you can adjust this, initially, in 0.01 increments and test drive your train in openBVE until your speedometer is calibrated correctly (press Ctrl+V multiple times as required in-game, and compare the actual speed with the speed shown on the speedometer). Alternatively, you can temporarily replace the variable speedometer with a value in m/s (converted from the unit of measurement shown on your speedometer), check the calibration via ObjectViewer, and adjust the last value accordingly. The other rotation commands are there to tilt the axis around which the needle rotates, to match the sloped 323's panel.
The rotatexfunction line allows both brake and power notches to be taken into account; adjust the -0.125 value to change the angle of the controller when position P1 or above is chosen, and similarly the value 0.10 for the brake steps. While determining what values to use, you can temporarily replace the above function in rotatexfunction with a simple function in the form of ROTATION_VALUE * x, where the former determines the degree of rotation, and x represents your chosen power/brake setting (for example, in the case of the class 323, a value of 1 to 4 for position P1-P4, and similarly 1 to 4 for position B1 to B3 and EMG as we're using brakeNotchLinear here).
Also, the class 323's combined traction/brake controller doesn't just pivot back and forth; it's also offset slightly to the left during the P1-P4 steps compared to the B1-B3 steps (you can see this in the screenshot on the left), which is what the rotatezfunction and rotatezdamping commands are for.
The horn lever was straightforward to implement; it's rotation simply depends on the value of the ats24 plugin variable in this case. rotateyfunction = -0.3 simply rotates the object so it's perpendicular to the desk panel it's attached to.
Here, the illuminated DRA image is placed in the bottom half of the texture, while the top half of the image is transparent. By using a texture shifting function, no state change occurs, so you won't notice any momentarily untextured surface appearing which can happen when a state is changed and the object hasn't been loaded previously.
The three objects are flat, vertical surfaces which load a simple texture with a sunburst gradient fill, representing a glow (similar to the light_xxxxx.png signal glow images included with openBVE's compatibility signal objects, or the pantograph sparking effects I've shown previously). The glow colour in the texture is white, and the SetColor command is used to determine what colour headlight is depicted (a yellowish-white in the example above); this way, only one texture is needed. These objects are positioned just beyond the cab window, and the additive blending mode simulates the effect of illuminating whatever is behind the surface (the track and scenery, in this case). The height of the surface determines whether just the track, or the scenery, appears to be illuminated. The file "transparent.png" is a tiny, completely transparent PNG file loaded as the daytime texture, so the headlight effect is only visible in low light (as it's loaded as a nighttime texture), or when the .Brightness command is used.
The states are linked to the proving lights in the cab (ats20), and each object has it's surface repositioned to simulate headlights on the left or right, or centred in the case of the marker lights.
There is one caveat however; while this works well at night, or when in a tunnel during daytime, the effect doesn't look so good when passing beneath a short overbridge (i.e. where a low .Brightness value is set over a distance of just a few metres), as the headlight glow becomes visible here, when in reality it wouldn't. As a compromise, what I'll probably do in the final release, is reserve the headlight effect for the nighttime headlight configuration only, not the daytime configuration (possible with the UKMUt.dll plugin). You'll have to decide whether this minor issue is worth it or not.
I thought I'd talk a little about the 323's interior as well. The interior view features the expected things; i.e. seats and partitions, but I've also included working TV screens, working carriage lighting, raindrop effects which run down and streak across the windows at varying speeds (depending on the speed of the train), and ground illumination from the windows and sparking pantograph.
The pluginstate[i] variables are there so that the TVs are only switched on when there's power, and stay on when passing though a neutral section (ats31 is the Line Volts indicator, and ats33 the Vacuum Circuit Breaker indicator). The refreshrate = 0.01 line just adds a slight degree of flickering to the screen.
Incidentally, I've now adopted more or less the same technique developed by michelle for openBVE's compatibility signal objects where my own signal aspect/lens and glow effects are concerned, as it's obvious that a lot of care went into these effects, and they look superb when applied to my own signal objects with the lens hoods as well (see the video…).
Lastly, I've updated my old Animated Exterior Car Objects blog entry to include some updated unctions which resolve a problem with the code which I hadn't considered previously. Bascially, the code I used meant that the pantograph animation speed was dependent on the framerate on the user's computer, which is obviously no good — if slow framerates were encountered, the animation would proceed very slowly, while if high framerates were experienced, the animation speed would be too high. By incorporating the delta variable and a factor into the functions, this problem is solved. Actually this should have occured to me, because I observed this behaviour when I was experimenting with the wheel rotation initially… D'oh. Thanks michelle !


Denver's South Metro is home to many influential neighborhoods including The Village Castle Pines, Castle Rock, Highlands Ranch, Broadmoor, and more. Covering the southern I-25 corridor, South Metro also features the prominent Denver Tech Center with numerous Fortune 500 companies, Centennial Airport, plentiful shopping destinations, renowned golf courses, recreational activities, and an abundance of restaurants.
Living in South Metro provides residents easy access to parks, scenery, national forests, and the open space that Colorado is known for. Homes within these neighborhoods often feature large lots with expansive views or condominiums with added amenities.
LIV Sotheby's International Realty's South Metro Micro Market Report includes many notable highlights for the area, comparing Q1 of 2019 to Q1 of 2018. The most impressive was displayed in Sedalia with a 131.3% increase in average price to $1,070,300 in 2019, from $462,640 in 2018. Another significant increase in average price was shown in Pradera & Timbers with a 50.7% increase in 2019 to $1,037,131, from $688,245 in 2018.
Proving to be an active and competitive area of the state, many areas also reported exciting increases in the number of properties sold for 2019. Highlands Ranch increased by 170.9% for properties sold to 279 in Q1 of 2019, from 103 in Q1 of 2018. Castle Pines also increased by an outstanding 76.9% to 23 properties sold in 2019, from 13 properties sold in 2018.
The South Metro neighborhoods offer a unique and desirable Colorado lifestyle with many surrounding attractions. Overall, many South Metro neighborhoods saw increases in both average price and number of properties sold, indicating a very healthy and active real estate market.
Backcountry, Bell Mountain Ranch, Broadmoor, Castle Pines, Castle Pines Village, Castle Rock, Colorado Springs, Diamond Ridge, Firelight, Highlands Ranch, Inverness, Keene Ranch, Larkspur, Lone Tree, Parker, Pradera & Timbers, Sedalia, and The Meadows.


text:
21 Christopher Way , Eatontown, NJ, 07724
2000 Linwood Ave Suite 1C, Fort Lee, NJ, 07024
Mt. Laurel, NJ
125 Sixth Avenue Suite 201, Mt. Laurel, NJ, 08054
What We Do For NJ
Refinance Account Verification Letters
Board Applications
Maryland Community Association Manager Earns Industry Professional Designation
TOWSON, MD. (October 24, 2019) – FirstService Residential, the leading residential property management company in North America, is proud to announce that its own Matthew Dozier, general manager, recently joined an elite group of community association managers who have earned the Large-Scale Manager (LSM®) credential from the Community Associations Institute (CAI). Dozier is one of only 106 managers nationwide who have earned this prestigious designation.
"We're thrilled that Matthew has achieved this level in his career," said Michael Mendillo president, FirstService Residential. "He continues to be an asset to FirstService Residential, going above and beyond each and every day for the communities we serve."
Dozier started with FirstService Residential in 2012 and has over a decade of experience managing community associations. For the past seven years, he has been an on-site manager for multi-generational and active adult communities. Prior to joining FirstService Residential, Dozier managed mixed-use, condominium, high-rise and single-family home communities in the southeast. He brings a strong collaborative style of leadership, as well as a proven record of accomplishments in sound fiscal management, implementation of cost-saving initiatives and facility operations to the communities he manages.
"The LSM designation is the pinnacle of designations for managers in our industry," said Trent Harrison, CMCA®, AMS®, PCAM®, president, MidAtlantic, FirstService Residential. "It better positions FirstService Residential and Matthew with respect to understanding the unique aspects and needs of a large-scale community."
"My pursuit of the LSM designation has always been about gaining new insights into my profession," said Dozier. "It's like gaining a key to open a door that leads to gaining new perspectives as a community association manager."
CAI is an international organization dedicated to building better communities. To earn the specialized LSM credential, managers must have 10 years of experience in community association management and complete more than 100 hours of course work. They must also have earned the industry's highest credential, the Professional Community Association Manager (PCAM®) designation. Continuing education and adherence to a code of ethics are also required.
About FirstService Residential
FirstService Residential is North America's property management leader, partnering with 8,000 communities across the U.S. and Canada, including low-, mid- and high-rise condominiums and cooperatives; single-family communities; master-planned, lifestyle and active adult communities; and mixed-use and rental properties. HOAs, community associations and condos rely on their extensive experience, resources and local expertise to maximize property values and enhance their residents' lifestyles.
Dedicated to making a difference, every day, FirstService Residential goes above and beyond to deliver exceptional service. FirstService Residential is a subsidiary of FirstService Corporation (FSV), a North American leader in the property services sector. For more information, visit www.fsresidential.com.
21 Christopher Way
Customer Care Center: Available 24 hours a day, 7 days a week


Wondering how to exterminate that old stain making your carpet or furniture look worthless???
In case you are trying to get rid of them on your own, you need to stop right now because you are just adding in salt to the injury. The problem with stains is that the longer they stay in, the harder they are to remove and the attempts to remove them on your own makes the situation even worse.
Our extremely devoted, highly skilled, expert stain removal team has been conquering these stains for years, no matter how older and stubborn they are and are yet to find any stain remaining unconquered.Without a shadow of a doubt, our high pressure stain removal equipments are unbelievably powerful to deal with these stains as if they never existed before. After our service, you won't be able find any stains or even any mark of them.
call us today on 04-887 1102. or fill out the free Quote form.


text:
Free Picks » NBA Picks » Milwaukee Bucks at Boston Celtics 4/12/2017 Free NBA Picks & Predictions
Milwaukee Bucks at Boston Celtics 4/12/2017 Free NBA Picks & Predictions
by Josh Schonwald - 4/11/2017
The Milwaukee Bucks travel to TD Garden to play the Boston Celtics on Wednesday, April 12, 2017. The opening line for this matchup has Boston as 8.5 point favorites.
The Bucks come into this game with an overall record of 42-39. They are 2nd in the Central Division. They currently have a point differential of 0.0 as they are averaging 103.7 points per game while giving up 103.7 per contest. The Celtics have an overall record of 52-29. They currently are 1st in the Atlantic Division. They are averaging 108.0 points per game and surrendering 105.5, good for a point differential of 2.5.
Valuable Milwaukee Bucks Betting Trends
The Milwaukee Bucks are 36-45-0 against the spread
The Milwaukee Bucks are 42-38-1 against the over/under
Important Boston Celtics Betting Trends
The Boston Celtics are 39-40-2 against the spread
The Boston Celtics are 38-42-1 against the over/under
Key Milwaukee Bucks Injuries
02/09/17 F Jabari Parker ACL out for season
Key Boston Celtics Injuries
No key injuries to report
Giannis Antetokounmpo comes into this contest averaging 22.9 points per game while playing 35.6 minutes per night so far this season for the Bucks. He pulls down 8.7 rebounds per game and dishes out 5.4 assists per game as well. His field goal percentage is 52% while his free throw percentage is currently at 77%. Greg Monroe averages 11.8 points per game in 22.6 minutes per contest this season. He averages 2.3 assists per contest and 6.6 rebounds per game for Milwaukee. His field goal percentage is 53% for the year while his free throw percentage is 74%.
Isaiah Thomas averages 29.1 points per game while playing 34 minutes per contest this year for the Celtics. He grabs 2.7 rebounds per game and has 5.9 assists per contest on the year. His field goal percentage is 46% and his free throw percentage currently is at 91%. Al Horford averages 14 points per game this season and he sees the court an average of 32.4 minutes per contest. He also averages 6.8 rebounds per contest and 5 assists per game. His field goal percentage is 47% and his free throw percentage is 80%.
Milwaukee averages 103.7 points per contest this season which ranks them 20th in the NBA. Their average scoring margin is 0.04 and their shooting percentage is 47% as a team which has them ranked 4th. Behind the arc they shoot 37% which is good for 10th in the league. They average 40.3 rebounds per game and 24.2 assists per game which ranks them 29th and 5th in those offensive categories. In the turnover department they rank 13th with 13.9 per game. The Bucks allow 103.7 points per game to their opponents which ranks them 9th in the league. They also allow a 46% shooting percentage and a 35% average from behind the arc ranking them 17th and 10th in those defensive categories. Opponents average 42.4 rebounds a game which ranks 8th and they give up 24 assists per contest which puts them in 26th place in the league. They force 14.8 turnovers per game which ranks them 22nd in the league.
Boston averages 108 points per game this year which ranks them 7th in the league. Their average scoring margin is 2.44 and their shooting percentage is 45% as a team which has them sitting in the 15th spot in the league. Behind the arc they shoot 36% which is good for 14th in the NBA. They average 41.9 rebounds per game and 25.2 assists per contest which ranks them 27th and 3rd respectively. In the turnover department the Celtics rank 22nd with 13.3 per game. The Celtics allow 105.5 points per game to their opponents which ranks them 14th in the league. They also allow a 45% shooting percentage and a 33% average from behind the arc ranking them 6th and 2nd in those defensive statistics. Opponents average 44.5 rebounds a game which ranks 25th and they give up 22.5 assists per contest which puts them in 12th place in the league. The Celtics force 13.9 turnovers per game which ranks them 15th in the NBA.
The Bucks have an offensive rating of 109.2 and a defensive rating of 109.2. In terms of pace they average 94.5 possessions per 48 minutes and their effective field goal percentage is 53%. As a team they have a true shooting percentage of 57% and they shoot 3 pointers on 29% of their shots. Milwaukee turns the ball over an average of 13.2 times per 100 possessions and they force 13.7 on the defensive end. Their defensive effective field goal percentage for the season currently is 52%.
The Celtics rating on offense is 111.1 and they have a defensive rating of 108.6. They get 96.8 possessions per 48 minutes and they have an effective field goal percentage of 53%. As a unit they have a true shooting percentage of 57% and they attempt 3 pointers on 39% of their shot attempts. Boston turns the ball over on 12.3 out of every 100 possessions and their opponents average 12.5 turnovers per 100 possessions. Their defensive effective field goal percentage for the year is 50%.
Who will win tonight's Bucks/Celtics NBA game against the spread?
Josh's Pick: Take Boston -8.5


I love it. Worth buying.
Same as the original different colour. All good Thanks.
Nice band! I'm very satisfied!
The product is of quality, but bought thinking it was the heart meter and is just the bracelet. useless to me.
Figment as muestra in las images, very good material.


text:
Cable fuels Cambridge privatisation speculation
by Imogen Goodman
This article is 11 years old
Business Secretary Vince Cable has fuelled speculation that Cambridge and other Russell Group Universities could go private in the near future.
In a speech given at the Girls' Schools Association Conference, he cited the threat of privatisation as one of the key reasons for government plans to increase tuition fees, stating that "fees keep universities public."
His comments follow media speculation earlier in the month that Cambridge was planning to go private as a result of reforms in government funding for Higher Education institutions.
The Comprehensive Spending Review, released on the 20th October, outlined plans to slash the budget for Higher Education by 40 per cent over the next four years. Lord Browne's controversial report proposed lifting the current tuition fee cap of £3,290 a year in order to replace the money lost in cuts to state funding.
Cable pointed out that the Browne Review had originally proposed removing the cap on fees entirely, but this had been rejected by the government due to concerns that it would unduly affect students from poorer backgrounds. The current government proposals stand at annual fees of £9,000, on the condition that institutions take adequate measures to improve access.
Speaking at the conference, Cable said, "One of the reasons we are doing this is precisely to head off Oxford, Cambridge, London School of Economics, University College London from going private, because if we had not opened up the system in the way we have, they would have had a very strong incentive to do so. Whether we will head them off or not, I don't know."
Cable indicated that the government had been under pressure from particular institutions to lift the cap on fees, but stated that universities would be much less likely to privatise under the current proposals, which, he claimed, would be profitable for them.
"It's a little bit like bankers who say if you're going to put some kind of tax on us we'll run away to Singapore. Universities have been playing this game with us – let us have unlimited fees or we'll privatise. I don't believe it.
"I think what we're proposing is a fair settlement which will provide them with enough income to provide high quality education and which is also fair to the pupils".
Cambridge-alumnus Cable said that he would "very much regret it" if the University did privatise, but said that he found it hard to imagine either Cambridge or Oxford taking this step, primarily due to the complicated logistics of the collegiate system.
Cambridge has stated that "the University has no position on these matters," and responses from fellows have been profoundly ambivalent.


text:
Denmark -Conservative party proposal to undercut collective agreements -September 7, 2012
Denmark -Conservative party proposal to undercut collective agreements -September 7, 2012 https://wageindicator.org/labour-laws/collective-bargaining/2012/news-items-2012/denmark-conservative-party-proposal-to-undercut-collective-agreements-september-7-2012 https://wageindicator.org/@@site-logo/wageindicator.png
According to the Employment Ministry a proposal by Dansk Folkeparti (DF) and Venstre (V), if approved by a majority in Parliament, would force some workers to work for salaries as low as 30 kroner an hour and without the right to strike. The proposal was made to limit the rights of trade unions to enter into conflicts with businesses that sign collective bargaining agreements with independent unions that tend to leave their employees worse off. According to the Employment Ministry, this would open up the possibility of employers getting away with substantially lower salaries and could undermine the working conditions that have been secured through the Danish employment model.
English: http://cphpost.dk/news/national/venstre-proposal-could-mean-30-kroner-hour ...
For more information, please contact the editor Jan Cremers, Amsterdam Institute for Advanced Labour Studies (AIAS) cbn-aias@uva.nl or the communications officer at the ETUI, Mariya Nikolova mnikolova@etui.org. For previous issues of the Collective bargaining newsletter please visit http://www.etui.org/E-Newsletters/Collective-bargaining-newsletter. You may find further information on the ETUI at www.etui.org, and on the AIAS at www.uva-aias.net.
© ETUI aisbl, Brussels 2012. All rights reserved.
Cite this page: © WageIndicator 2020 - WageIndicator.org - Denmark -Conservative party proposal to undercut collective agreements -September 7, 2012


Everybody knows that continuous integration is our bight future, it reduces costs, improves testing response times, etc. Internet is full of examples how to set up CI on small scale – for one project with one or two git repositories. But how to scale these simple ideas up to your complex product needs? Within this talk I'll share our Tieto Cards experience how we got Jenkins Pipeline based CI running for our medium size product.