def makeStandardRequest(self, method, entity, temporalContext, timeSeries, serviceUri, publicKey, *valueObjects): ''' @return: Activity ''' from SmartAPI.factory.Factory import Factory from SmartAPI.common.Tools import Tools from SmartAPI.model.Response import Response req = Factory.createRequest(publicKey, method, Factory.defaultIdentity, entity, temporalContext, timeSeries, *valueObjects) # from the object, find activity that is for the required method and that supports most of the valueObjects a = Tools.getMostCommonActivity(method, False, entity, *valueObjects) if serviceUri is None: serviceUri = self._findHTTPInterfaceUri(entity, a) resp = None try: resp, headers = self.sendPost( serviceUri, Tools.toString(req), seasMethod=self.SMARTAPI_METHOD_REQUEST) resp = Response.fromString(resp, 'text/turtle') if resp.hasActivity(): if resp.firstActivity().hasEntity(): return resp.firstActivity() else: return None except: print "object request with HTTP client failed. Method: ", method traceback.print_exc() return None
def search(self): from SmartAPI.model.Response import Response # serialize data messageBody = self._generateSearchMessage() if self.debug: print '\n Request to SEAS Search Service:' print messageBody, '\n' try: # send message responseStr = self.httpClient.sendPost(self.rsUri, messageBody, self.serialization, self.serialization, seasMethod=self.httpClient.SMARTAPI_METHOD_REQUEST)[0] response = Response.fromString(responseStr, self.serialization) if response is not None: if self.debug: print '\n Response from SEAS Search Service:' print Tools.toString(response, self.serialization) Tools.printErrors(response) return response.getEntities() else: if self.debug: print '\n Response from SEAS Search Service:' print responseStr, '\n' return None except: print 'Exception while sending an HTTP request to ', self.rsUri traceback.print_exc()
def decrypt(self, key, serialization=SERIALIZATION.TURTLE): ''' Decrypt with SessionKey. Using encrypted string to recover the original Object. @return a new Obj decrypted from cipertext, without those additional types like EncryptedReference and Reference, which were inserted by encrypt() method before. ''' if self.encryptedStringRepresentation is not None: if isinstance(key, RSA._RSAobj): decryptedString, symkey = SmartAPICrypto().asymmetricDecrypt( key, self.encryptedStringRepresentation) else: decryptedString = SmartAPICrypto().symmetricDecrypt( key, self.encryptedStringRepresentation) model = Tools().fromString(decryptedString, serialization) # find the resource which was encrypted rootRes = Tools().getTopNode(model)[0] # figure out its SMARTAPI Class seasCls = Tools().getResourceClass(rootRes) # recover it to Obj or its subclass Object recoveredObj = seasCls.parse(rootRes) # remove EncryptedReference and Reference types. recoveredObj.types.remove(URIRef(RESOURCE.ENCRYPTEDREFERENCE)) recoveredObj.types.remove(URIRef(RESOURCE.REFERENCE)) self.__dict__.update(recoveredObj.__dict__) return recoveredObj else: pass
def fromString(self, data, serialization): try: return Request().parse(Tools().getResourceByType(RESOURCE.REQUEST, Tools().fromString(data, serialization))) except: print "Unable to parse Evaluation by type smartapi:Request from the given string." traceback.print_exc() return None
def fromString(cls, data, serialization): from SmartAPI.common.Tools import Tools try: return cls.parse(Tools().getResourceByType(RESOURCE.REQUEST, Tools().fromString(data, serialization))); except: print "Unable to parse Request from the given string." traceback.print_exc() return None
def fromString(self, data, serialization): try: return Response().parse(Tools().getResourceByType( RESOURCE.RESPONSE, Tools().fromString(data, serialization))) except: print "Unable to parse Response by type seas:Response from the given string." traceback.print_exc() return None
def fromString(self, data, serialization): try: return Evaluation().parse(Tools().getResourceByType( RESOURCE.COMMAND, Tools().fromString(data, serialization))) except: print "Unable to parse Evaluation by type seas:Command from the given string." traceback.print_exc() return None
def fromString(self, data, serialization): try: return Notification().parse(Tools().getResourceByType( RESOURCE.NOTIFICATION, Tools().fromString(data, serialization))) except: print "Unable to parse Evaluation by type seas:Notification from the given string." traceback.print_exc() return None
def fromString(cls, data, serialization): try: return cls.parse(Tools().getResourceByType( RESOURCE.ALIVERESPONSE, Tools().fromString(data, serialization))) except: print "Unable to parse AliveResponse from the given string." traceback.print_exc() return None
def parseStatement(self, statement): # get predicate predicate = str(statement.getPredicate()) if predicate == PROPERTY.KEY: try: self.setKey(statement.getString()) except: print "Unable to interpret seas:key value as literal for Parameter." traceback.print_exc() return if predicate == PROPERTY.RDF_VALUE: target_class = Tools().getResourceClass(statement.getResource()) if target_class is not None: try: self.addValue(target_class().parse(statement.getResource())) except: print "Unable to interpret rdf:value as value for Parameter." traceback.print_exc() return elif statement.getResource().model.is_list(statement.getObject()): l = [] statement.getResource().model.parse_list(l, statement.getObject()) self.addValue(l) else: self.addValue(Variant().parse(statement)) return # pass on to Object super(Parameter, self).parseStatement(statement)
def parse(self, statement): # get predicate and object predicate = str(statement.getPredicate()) objectNode = statement.getObject() # if literal object dataType = None if isinstance(objectNode, Literal): return Variant(objectNode.toPython()) elif (statement.getResource() is not None): resource = statement.getResource() klass = Tools().getResourceClass(resource, default=Obj) if klass is not None: v = klass().parse(resource) else: # None found, resort to Obj (the base class) v = Obj().parse(resource) return v elif isinstance(objectNode, BNode): l = [] statement.getResource().getModel().parse_list(l, objectNode, None) return l elif isinstance(objectNode, URIRef): return Variant(objectNode) # could not identify datatype print "Parsing variant failed. Unable to detect RDFDatatype (" + str( dataType) + ") for literal." return Variant("")
def _generateSearchMessage(self): from SmartAPI.factory.RequestFactory import RequestFactory request = RequestFactory().create(self.generatedBy) request.setMethod(RESOURCE.READ) request.addEntity(self.entity) return Tools.toString(request, self.serialization)
def sendPostWithRequest(self, server_uri, request_obj, serialization=SERIALIZATION.getMimeType( SERIALIZATION.TURTLE)): ''' It serializes Request message into a string (no MIME headers) and send out via HTTP POST. Then it parses received response message into Response object. Note: this function assumes HTTP server generates Smart API Response string in payload without MIME header @param server_uri: uri string of the remote server @param request_obj: Request object @return Response object ''' from SmartAPI.common.Tools import Tools payload, content_type = Tools.serializeRequest(request_obj, serialization) response_body, response_headers = self.sendPost( server_uri, payload, content_type=content_type) resp = Tools.parseResponse(response_body, content_type) return resp
def generateRegistrationMessage(self, entity = None): if entity: self.addEntity(entity) # check that there is something to register if len(self.entities) < 1: raise InsufficientDataException("No SMARTAPI entities found in registration.") # build registration request request = RequestFactory().createRegistrationRequest(self.identity) for e in self.entities: request.addEntity(e) # store timestamp for later to check if registration was successful self.timestamp = request.getGeneratedAt(); return Tools().toString(request, self.serialization)
def explain(self): ''' Similar is seasPrint() method, but add detailed explaination for each concept ''' from rdflib import Graph, resource, URIRef, RDF, Literal from sets import Set from SmartAPI.common.NS import NS from SmartAPI.common.Tools import Tools # if this Obj has no SeasIdentifierUri, add a temporary one in order to make Resource creating easier. temporaryURI = False if self.getIdentifierUri() is None: temporaryURI = True self.setIdentifierUri('http://temporary.org/rdflib/seas#temporary') # get the underlying rdf graph st = Tools.toString(self, 'text/turtle') g = Graph() g.parse(data=st, format='turtle') g.bind('smartapi', NS.SMARTAPI) g.bind('geo', NS.GEO) g.bind('qudt', NS.QUDT) g.bind('unit', NS.UNIT) g.bind('quantity', NS.QUANTITY) g.bind('owl', NS.OWL) g.bind('vcard', NS.VCARD) g.bind('gr', NS.GR) g.bind('dc', NS.DC) # get the root resource root = resource.Resource(g, URIRef(self.getIdentifierUri())) indent = '' if temporaryURI: # delete the temporary URI. It is not useful any more. self.setIdentifierUri(None) self.treePrint(root, indent)
def printOut(self): ''' show structure and datatype of this Obj. It corresponds to print() method in Obj.java. ''' from rdflib import Graph, resource, URIRef, RDF, Literal from sets import Set from SmartAPI.common.NS import NS # if this Obj has no SeasIdentifierUri, add a temporary one in order to make Resource creating easier. temporaryURI = False if self.getIdentifierUri() is None: temporaryURI = True self.setIdentifierUri('http://temporary.org/rdflib/seas#temporary') # get the underlying rdf graph st = Tools.toString(self, 'text/turtle') g = Graph() g.parse(data=st, format='turtle') g.bind('smartapi', NS.SMARTAPI) g.bind('geo', NS.GEO) g.bind('qudt', NS.QUDT) g.bind('unit', NS.UNIT) g.bind('quantity', NS.QUANTITY) g.bind('owl', NS.OWL) g.bind('vcard', NS.VCARD) g.bind('gr', NS.GR) # get the root resource root = resource.Resource(g, URIRef(self.getIdentifierUri())) indent = '' if temporaryURI: # delete the temporary URI. It is not useful any more. self.setIdentifierUri(None) self.treePrintNoDetails(root, indent)
def _parse_list_entry(self, entry, klass=None, from_nude=False): from SmartAPI.model.ValueObject import ValueObject from SmartAPI.rdf.Variant import Variant from SmartAPI.common.Tools import Tools if from_nude and klass is not None: item = klass() item.fromNude(entry) return item if isinstance(entry, Literal): return Variant(entry.toPython()) elif isinstance(entry, URIRef): if entry == RDF.nil: return None return Variant(entry) else: if klass is None: types = [] sl = self.listStatements(subject=entry, predicate=URIRef(PROPERTY.RDF_TYPE), object=None) for s in sl: types.append(s.getResource().toString()) klass = Tools().mapper.getClass(types, default=Variant) item = klass() for s in self.find_statements_for_node(entry): if s.predicate == NS.SMARTAPI + "valueObject": itemv = ValueObject() for sv in self.find_statements_for_node(s.object): itemv.parse(sv) item.addValueObject(itemv) else: item.parseStatement(s) return item
def storeToTransactionServer(cls, senderId, notary, *args): ''' @param senderId: URI string @param notary: URI string @param args: a variable number of Transaction Objects @return a boolean value ''' try: client = HttpClient() # create an empty MIME multipart message sentHttpMessage = HttpMessage() # construct Request object req = RequestFactory().create(senderId) req.setMethod(RESOURCE.WRITE) cls.messageIdCounter = cls.messageIdCounter + 1 req.setMessageId(cls.messageIdCounter) a = Activity() req.addActivity(a) i = Input() a.addInput(i) system = SystemOfInterest() system.setSameAs(notary) i.setSystemOfInterest(system) param = Parameter() param.setKey("transactions") param.setName("Transaction id list") param.setDescription( "List of ids of transactions that are sent for storing into the database." ) for transaction in args: param.addValue(transaction.getIdentifierUri()) i.addParameter(param) # save Request object to multipart message, Main part mainRequestString = Tools.toString(req) sentHttpMessage.addMainpart(mainRequestString) mainRequestHash = SmartAPICrypto().createEncodedMessageDigest( mainRequestString) requestSignature = SmartAPICrypto().sign( CryptoKeyWallet.getPrivateKey(), mainRequestHash) # create transaction for the main request if cls.transactionIdentifierUriPrefix == '': transactionIdentifierUri = senderId + uuid.uuid4().get_hex() else: transactionIdentifierUri = cls.transactionIdentifierUriPrefix + uuid.uuid4( ).get_hex() requestTransaction = Factory.createTransaction( transactionIdentifierUri, senderId) requestTransaction.setSigner(senderId) requestTransactionMessage = Message() requestTransactionMessage.setMessageId(req.getMessageId()) requestTransactionMessage.setHashCode(mainRequestHash) requestTransactionMessage.setSignature(requestSignature) requestTransaction.setMessage(requestTransactionMessage) # save requestTransaction to multipart message, non-Main part requestTransactionString = Tools.toString(requestTransaction) sentHttpMessage.add(transactionIdentifierUri, requestTransactionString) # save transactions that are sent to multipart message, non-Main part for trans in args: sentHttpMessage.add(trans.getIdentifierUri(), Tools.toString(trans)) # send out this multipart message payload = removeFrontHeader(sentHttpMessage.asString()) #print '*** sent ****' #print payload #print '*************' resp, contentType = client.sendPost( notary, payload, sentHttpMessage.getContentType()) #print "----response -----" #print resp return True except: traceback.print_exc() return False
def serializeToReference(self, model): ''' serialize to an encrypted version of this Object. Its actual content is saved in Tools.messageParts @return: a rdf Resource ''' from SmartAPI.agents.TransactionAgent import TransactionAgent # generate a SeasIdentifierUri for this object if not yet exist. Anonymous is not allowed here. if (self.hasIdentifierUri() == False): self.setIdentifierUri(self.referenceUriPrefix + str(uuid.uuid4())) # convert current Object to string for later encryption self.serializeAsReference = False partString = Tools().toString(self, SERIALIZATION.TURTLE) # TODO: formalize this to a proper encoding method partString = partString.replace("\n", "\r\n") partString = partString.replace("\r\n\r\n", "\r\n") # using the string to generate encrypted string crypto = SmartAPICrypto() if self.encrypted: # encrypting the normally serialized Object # symmetric with notary if self.getEncryptionKeyType() == RESOURCE.NOTARIZEDSESSIONKEY: sessionkey = crypto.generateSymmetricKey() partString = crypto.symmetricEncrypt(sessionkey, partString) # encrypt session key with recipient's public key encryptedKey = crypto.encryptAndEncodeKey( self.encryptKey, sessionkey) # calculate hashcode hash = crypto.createEncodedMessageDigest(partString) self.setHashCode(hash) if self.signed: signature = crypto.sign(self.privateKey, partString) self.setSignature(signature) # send encryptedKey to notary for storing if not TransactionAgent.sendKeyToNotary( self.senderId, self.getIdentifierUri(), hash, encryptedKey, self.getSignature(), self.getNotary()): raise Exception( "Sending notarized session key to notary failed.") # with public key if self.getEncryptionKeyType() == RESOURCE.PUBLICKEY: # encrypt data with encrypted session key attached partString = crypto.asymmetricEncrypt(self.encryptKey, partString)[0] # with only session key. *insecure* if self.getEncryptionKeyType() == RESOURCE.SESSIONKEY: # encrypt data partString = crypto.symmetricEncrypt(self.encryptKey, partString) # save key to reference sessionkeyAsString = base64.b64encode(self.encryptKey) self.setSessionKey(sessionkeyAsString) if not self.hasHashCode(): hash = crypto.createEncodedMessageDigest(partString) self.setHashCode(hash) if self.signed and (not self.hasSignature()): signature = crypto.sign(self.privateKey, partString) self.setSignature(signature) # save encrypted or unencrypted partString and its uri to multipart as body part Tools.saveForMessageParts(self.getIdentifierUri(), partString) # add all these to the new Resource # Note: MULTIPARTREFERENCE type is not included in encrypted string representation. self.addType(RESOURCE.MULTIPARTREFERENCE) resource = model.createResource(self.getIdentifierUri()) # type typeProp = model.createProperty(PROPERTY.RDF_TYPE) for type in self.types: try: serialized = type.serialize(model) except: serialized = URIRef(type) resource.addProperty(typeProp, serialized) #sessionKey if self.hasSessionKey(): resource.addProperty( model.createProperty(PROPERTY.SESSIONKEY), model.createTypedLiteral(self.sessionKey, XSD.string)) #signature if self.hasSignature(): resource.addProperty( model.createProperty(PROPERTY.SIGNATURE), model.createTypedLiteral(self.signature, XSD.string)) # hashcode if self.hasHashCode(): resource.addProperty( model.createProperty(PROPERTY.HASHCODE), model.createTypedLiteral(self.hashCode, XSD.string)) # encryptionKeyType if self.hasEncryptionKeyType(): resource.addProperty( model.createProperty(PROPERTY.ENCRYPTIONKEYTYPE), model.createResource(self.getEncryptionKeyType())) # notary if self.hasNotary(): resource.addProperty(model.createProperty(PROPERTY.NOTARY), model.createResource(self.getNotary())) return resource
def fetchFromTransactionServer(cls, senderId, notary, *args): ''' @param senderId: URI string @param notary: URI string @param args: a variable number of Transaction Objects @return a dictionary, key is SeasIdentifierUri of each transaction, value is Transaction Object ''' try: client = HttpClient() # create an empty MIME multipart message sentHttpMessage = HttpMessage() # main request req = RequestFactory().create(senderId) req.setMethod(RESOURCE.READ) cls.messageIdCounter = cls.messageIdCounter + 1 req.setMessageId(cls.messageIdCounter) a = Activity() req.addActivity(a) i = Input() a.addInput(i) system = SystemOfInterest() system.setSameAs(notary) i.setSystemOfInterest(system) param = Parameter() param.setKey("transactions") param.setName("Transaction id list") param.setDescription( "List of ids of transactions that are sent to be fetched the database." ) for transaction in args: param.addValue(transaction.getIdentifierUri()) i.addParameter(param) # save Request object to multipart message, Main part mainRequestString = Tools.toString(req) sentHttpMessage.addMainpart(mainRequestString) mainRequestHash = SmartAPICrypto().createEncodedMessageDigest( mainRequestString) requestSignature = SmartAPICrypto().sign( CryptoKeyWallet.getPrivateKey(), mainRequestHash) #create transaction for the main request if cls.transactionIdentifierUriPrefix == '': transactionIdentifierUri = senderId + uuid.uuid4().get_hex() else: transactionIdentifierUri = transactionIdentifierUri + uuid.uuid4( ).get_hex() requestTransaction = Factory.createTransaction( transactionIdentifierUri, senderId) requestTransaction.setSigner(senderId) requestTransactionMessage = Message() requestTransactionMessage.setMessageId(req.getMessageId()) requestTransactionMessage.setHashCode(mainRequestHash) requestTransactionMessage.setSignature(requestSignature) requestTransaction.setMessage(requestTransactionMessage) # add requestTransaction to multipart message, non-Main part requestTransactionString = Tools.toString(requestTransaction) sentHttpMessage.add(transactionIdentifierUri, requestTransactionString) # add transactions that are sent to multipart message, non-Main part for trans in args: sentHttpMessage.add(trans.getIdentifierUri(), Tools.toString(trans)) # send out this multipart message payload = removeFrontHeader(sentHttpMessage.asString()) resp, contentType = client.sendPost( notary, payload, sentHttpMessage.getContentType()) receivedHttpMessagestr = addFrontHeader(resp, contentType) receivedHttpMessage = parseMIMEmessage(receivedHttpMessagestr) map = {} if isinstance(receivedHttpMessage, HttpMessageSingle): non_main_parts_dict = {} else: non_main_parts_dict = receivedHttpMessage.getNonMainPartsAsDict( ) counter = 0 for part in non_main_parts_dict.values(): counter = counter + 1 # recover the part from string to Seas Obj model = Tools().fromString(part, SERIALIZATION.TURTLE) rootRes = Tools().getTopNode(model)[0] seasCls = Tools().getResourceClass(rootRes) recoveredObj = seasCls.parse(rootRes) if isinstance( recoveredObj, Transaction ): # We want to save the Transaction that hold the requested data map[recoveredObj.getIdentifierUri()] = recoveredObj return map except: traceback.print_exc()
def parseStatement(self, statement): ''' It takes in statement as input, add property to existing model Class object. Return None ''' from SmartAPI.model.Parameter import Parameter from SmartAPI.model.Provenance import Provenance from SmartAPI.model.Activity import Activity from SmartAPI.model.Offering import Offering # get predicate and object predicate = str(statement.getPredicate()) objectNode = statement.getObject() # type if predicate == PROPERTY.RDF_TYPE: self.addType(URIRef(statement.getResource().toString())) return # sameas if predicate == PROPERTY.SAMEAS: self.setSameAs(statement.getResource().toString()) return # generatedby if predicate == PROPERTY.GENERATEDBY: self.setGeneratedBy(Activity.parse(statement.getResource())) return # generatedat if predicate == PROPERTY.GENERATEDAT: self.setGeneratedAt(statement.getObject().toPython()) return # provenance if predicate == PROPERTY.PROVENANCE: self.addProvenance(Provenance.parse(statement.getResource())) return # offerings if predicate == PROPERTY.OFFERS: self.addOffering(Offering.parse(statement.getResource())) return # target if predicate == PROPERTY.TARGET: self.addTarget(statement.getString()) return # label if predicate == PROPERTY.RDFS_LABEL: self.setName(statement.getString()) return # comment if predicate == PROPERTY.COMMENT: self.setDescription(statement.getString()) return # sessionKey if predicate == PROPERTY.SESSIONKEY: self.setSessionKey(statement.getString()) return # signature if predicate == PROPERTY.SIGNATURE: self.setSignature(statement.getString()) return # hashcode if predicate == PROPERTY.HASHCODE: self.setHashCode(statement.getString()) return # encryptionKeyType if predicate == PROPERTY.ENCRYPTIONKEYTYPE: self.setEncryptionKeyType(statement.getResource().toString()) return # notary if predicate == PROPERTY.NOTARY: self.setNotary(statement.getResource().toString()) return # parameters if predicate == PROPERTY.PARAMETER: p = Parameter().parse(statement.getResource()) self.add(p.getKey(), p.getValues()) return # if literal object if isinstance(objectNode, Literal): self.add(URIRef(predicate), objectNode.toPython()) #print 'DEBUG: ', objectNode.datatype, '...', objectNode # if ((objectNode.datatype is not None) and objectNode.datatype == XSD.duration): # self.add(URIRef(predicate), statement.getString()) # else: # self.add(URIRef(predicate), objectNode.toPython()) return # if isinstance(objectNode, URIRef): # print "parse URI resource ", objectNode # self.add(URIRef(predicate), objectNode) # return # if resource if isinstance(objectNode, URIRef): resource = statement.getResource() # first check if resource has a type implemented built-in # and parse using that klass = Tools().getResourceClass(resource, default=Obj) if klass is not None: self.add(URIRef(predicate), klass.parse(resource)) else: # None found, resort to Obj (the base class) self.add(URIRef(predicate), Obj.parse(resource)) return # Nothing else matches, use BNode as blank default entry if isinstance(objectNode, BNode): try: klass = Tools().getResourceClass(statement.getResource(), default=None) except: klass = None if klass is not None: self.add(URIRef(predicate), klass.parse(statement.getResource())) else: self.add(URIRef(predicate), objectNode.toPython()) return
def parse(cls, element): ''' factory method and class method. It takes in Resource as parameter, create a Seas Obj or its subClass object. @return: this newly created object, which could be either a real Obj or its subclass Object or a Reference, whose actual content is in multipart message's body part ''' if isinstance(element, Resource) and Tools.parsedObjs.has_key( element.toString()): return Tools.parsedObjs.get(element.toString()) elif isinstance( element, Resource) and not Tools.parsedObjs.has_key(element.toString()): if not element.isAnon(): obj = cls(element.toString()) else: obj = cls() Tools.parsedObjs[element.toString()] = obj for i in element.findProperties(): obj.parseStatement(i) # check whether this Obj is a reference if obj.isOfType(RESOURCE.MULTIPARTREFERENCE): if obj.hasIdentifierUri(): if (len(Tools.messagePartsForParse) > 0) and (obj.getIdentifierUri() in Tools.messagePartsForParse): stringRepresentation = Tools.messagePartsForParse[ obj.getIdentifierUri()] # if this Obj is EncryptedReference, it will be decrypted later by decrypt() call. if obj.isOfType(RESOURCE.ENCRYPTEDREFERENCE): obj.encryptedStringRepresentation = stringRepresentation else: # if not encrypted, replace this reference Obj with a new Object, # which is deserialzed from the stringRepresentation, containing actual content. # This happens in the case of digital signature model = Tools().fromString(stringRepresentation, SERIALIZATION.TURTLE) # find the root Resource rootRes = Tools().getTopNode(model)[0] # figure out its SMARTAPI Class seasCls = Tools().getResourceClass(rootRes) # recover it to Obj or its subclass Object recoveredObj = seasCls.parse(rootRes) # copy signature, hashcode from reference Obj to recovered Obj recoveredObj.setSignature(obj.getSignature()) recoveredObj.setHashCode(obj.getHashCode()) recoveredObj.types.remove( URIRef(RESOURCE.REFERENCE)) obj = recoveredObj del Tools.messagePartsForParse[obj.getIdentifierUri()] else: raise Exception( '******* ERROR: can not find the encrypted string representation of {}' .format(obj.getIdentifierUri())) #try: # raise Exception('just to check!!!') #except: # traceback.print_stack() else: raise Exception( '***** ERROR: reference Obj has to be named!!!*******') return obj return None
def fromString(cls, data, serialization): m = Tools().fromString(data, serialization) res = Tools().getResourceByType(RESOURCE.ALIVEREQUEST, m) return cls.parse(res)
def turtlePrint(self): #raise Exception('turtlePrint is deprecated. Use turtleFormat and print out output yourself instead.') print '****** WARNING: turtlePrint is deprecated. Use turtleFormat and print out output yourself instead.' print Tools.toString(self)
def on_mqtt_publish(self, client, userdata, msg): n = Tools.parseNotification(msg.payload) self._cb(n)
def parseStatement(self, statement): from SmartAPI.model.Availability import Availability from SmartAPI.model.Input import Input from SmartAPI.model.Output import Output from SmartAPI.model.InterfaceAddress import InterfaceAddress from SmartAPI.model.Entity import Entity from SmartAPI.model.TimeSeries import TimeSeries from SmartAPI.model.TemporalContext import TemporalContext predicate = str(statement.getPredicate()) # method if predicate == PROPERTY.METHOD: try: self.setMethod(statement.getResource().toString()) except: print "Unable to interpret smartapi:method value as literal string." traceback.print_exc() return # input data if predicate == PROPERTY.HASINPUT: try: self.addInput(Input.parse(statement.getResource())) except: print "Unable to interpret smartapi:hasInput value as resource." traceback.print_exc() return # input reference if predicate == PROPERTY.HASREFINPUT: try: input = Input.parse(statement.getResource()) input.setInputType(Input.TYPE_REFERENCE) self.addInput(input) except: print "Unable to interpret smartapi:hasRefInput value as resource." traceback.print_exc() return # output if predicate == PROPERTY.HASOUTPUT: try: self.addOutput(Output.parse(statement.getResource())) except: print "Unable to interpret smartapi:hasOutput value as resource." traceback.print_exc() return # availability if predicate == PROPERTY.HASAVAILABILITY: try: self.addAvailability( Availability.parse(statement.getResource())) except: print "Unable to interpret smartapi:hasAvailability value as resource." traceback.print_exc() return # data availability if predicate == PROPERTY.HASDATAAVAILABILITY: try: self.addDataAvailability( Availability.parse(statement.getResource())) except: print "Unable to interpret smartapi:hasDataAvailability value as resource." traceback.print_exc() return # interfaceaddress if predicate == PROPERTY.INTERFACE: try: self.addInterface( InterfaceAddress.parse(statement.getResource())) except: print "Unable to interpret smartapi:interface value as resource." traceback.print_exc() return # entity if predicate == PROPERTY.ENTITY: try: self.addEntity(Tools.fromResourceAsObj( statement.getResource())) except: print "Unable to interpret smartapi:entity value (of type smartapi:Entity) as resource." traceback.print_exc() return # temporalcontext if predicate == PROPERTY.TEMPORALCONTEXT: try: self.setTemporalContext(TemporalContext().parse( statement.getResource())) except: print "Unable to interpret smartapi:temporalContext value as resource." traceback.print_exc() return # timeserie if predicate == PROPERTY.TIMESERIES: try: self.addTimeSerie(TimeSeries().parse(statement.getResource())) except: print "Unable to interpret smartapi:timeSeries value as resource." traceback.print_exc() return # pass on to Object super(Activity, self).parseStatement(statement)
def turtleFormat(self): return Tools.toString(self)
def generateSearchMessage(self): request = RequestFactory().create(self.identity) request.setMethod(RESOURCE.READ) request.addEntity(self.entity) return Tools().toString(request, self.serialization)
def asTime(self): try: return Tools().stringToDate(str(self.variant)).time() except: return None