Introduction
Deferreds are quite possibly the single most confusing topic that a newcomer to Twisted has to deal with. I am going to forgo the normal talk about what deferreds are, what they aren't, and why they're used in Twisted. Instead, I'm going show you the logic behind what they do.
A deferred allows you to encapsulate the logic that you'd normally use to make a series of function calls after receiving a result into a single object. In the examples that follow, I'll first show you what's going to go on behind the scenes in the deferred chain, then show you the deferred API calls that set up that chain. All of these examples are runnable code, so feel free to play around with them.
A simple example
First, a simple example so that we have something to talk about:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ Here we have the simplest case, a single callback and a single errback. """ num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) def handleResult(result): global num; num += 1 print "callback %s" % (num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def behindTheScenes(result): # equivalent to d.callback(result) if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() def deferredExample(): d = defer.Deferred() d.addCallback(handleResult) d.addErrback(handleFailure) d.callback("success") if __name__ == '__main__': behindTheScenes("success") print "\n-------------------------------------------------\n" global num; num = 0 deferredExample()
And the output: (since both methods in the example produce the same output, it will only be shown once.)
callback 1 got result: success
Here we have the simplest case. A deferred with a single callback and a
single errback. Normally, a function would create a deferred and hand it back
to you when you request an operation that needs to wait for an event for
completion. The object you called then does d.callback(result)
when the results are in.
The thing to notice is that there is only one result that is passed from
method to method, and that the result returned from a method is the argument
to the next method in the chain. In case of an exception, result is set to an
instance of Failure
that describes the exception.
Errbacks
Failure in requested operation
Things don't always go as planned, and sometimes the function that returned the deferred needs to alert the callback chain that an error has occurred.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ This example is analogous to a function calling .errback(failure) """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def behindTheScenes(result): if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() def deferredExample(result): d = defer.Deferred() d.addCallback(handleResult) d.addCallback(failAtHandlingResult) d.addErrback(handleFailure) d.errback(result) if __name__ == '__main__': result = None try: raise RuntimeError, "*doh*! failure!" except: result = failure.Failure() behindTheScenes(result) print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample(result)
errback we got an exception: Traceback (most recent call last): --- exception caught here --- File "deferred_ex1a.py", line 73, in ? raise RuntimeError, "*doh*! failure!" exceptions.RuntimeError: *doh*! failure!
The important thing to note (as it will come up again in later examples) is that the callback isn't touched, the failure goes right to the errback. Also note that the errback trap()s the expected exception type. If you don't trap the exception, an error will be logged when the deferred is garbage-collected.
Exceptions raised in callbacks
Now let's see what happens when our callback raises an exception
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ Here we have a slightly more involved case. The deferred is called back with a result. the first callback returns a value, the second callback, however raises an exception, which is handled by the errback. """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def behindTheScenes(result): if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback try: result = failAtHandlingResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() def deferredExample(): d = defer.Deferred() d.addCallback(handleResult) d.addCallback(failAtHandlingResult) d.addErrback(handleFailure) d.callback("success") if __name__ == '__main__': behindTheScenes("success") print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample()
And the output: (note, tracebacks will be edited slightly to conserve space)
callback 1 got result: success callback 2 got result: yay! handleResult was successful! about to raise exception errback we got an exception: Traceback (most recent call last): --- <exception caught here> --- File "/home/slyphon/Projects/Twisted/trunk/twisted/internet/defer.py", line 326, in _runCallbacks self.result = callback(self.result, *args, **kw) File "./deferred_ex1.py", line 32, in failAtHandlingResult raise RuntimeError, "whoops! we encountered an error" exceptions.RuntimeError: whoops! we encountered an error
If your callback raises an exception, the next method to be called will be the next errback in your chain.
Exceptions will only be handled by errbacks
If a callback raises an exception the next method to be called will be next errback in the chain. If the chain is started off with a failure, the first method to be called will be the first errback.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ This example shows an important concept that many deferred newbies (myself included) have trouble understanding. when an error occurs in a callback, the first errback after the error occurs will be the next method called. (in the next example we'll see what happens in the 'chain' after an errback). """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def behindTheScenes(result): # equivalent to d.callback(result) # now, let's make the error happen in the first callback if not isinstance(result, failure.Failure): # ---- callback try: result = failAtHandlingResult(result) except: result = failure.Failure() else: # ---- errback pass # note: this callback will be skipped because # result is a failure if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() def deferredExample(): d = defer.Deferred() d.addCallback(failAtHandlingResult) d.addCallback(handleResult) d.addErrback(handleFailure) d.callback("success") if __name__ == '__main__': behindTheScenes("success") print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample()
callback 1 got result: success about to raise exception errback we got an exception: Traceback (most recent call last): File "./deferred_ex2.py", line 85, in ? nonDeferredExample("success") --- <exception caught here> --- File "./deferred_ex2.py", line 46, in nonDeferredExample result = failAtHandlingResult(result) File "./deferred_ex2.py", line 35, in failAtHandlingResult raise RuntimeError, "whoops! we encountered an error" exceptions.RuntimeError: whoops! we encountered an error
You can see that our second callback, handleResult was not called because failAtHandlingResult raised an exception
Handling an exception and continuing on
In this example, we see an errback handle an exception raised in the preceeding callback. Take note that it could just as easily been an exception from any other preceeding method. You'll see that after the exception is handled in the errback (i.e. the errback does not return a failure or raise an exception) the chain continues on with the next callback.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ Now we see how an errback can handle errors. if an errback does not raise an exception, the next callback in the chain will be called. """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) return "okay, continue on" def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def callbackAfterErrback(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) def behindTheScenes(result): # equivalent to d.callback(result) if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback try: result = failAtHandlingResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() if not isinstance(result, failure.Failure): # ---- callback try: result = callbackAfterErrback(result) except: result = failure.Failure() else: # ---- errback pass def deferredExample(): d = defer.Deferred() d.addCallback(handleResult) d.addCallback(failAtHandlingResult) d.addErrback(handleFailure) d.addCallback(callbackAfterErrback) d.callback("success") if __name__ == '__main__': behindTheScenes("success") print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample()
callback 1 got result: success callback 2 got result: yay! handleResult was successful! about to raise exception errback we got an exception: Traceback (most recent call last): File "./deferred_ex3.py", line 97, in <module> deferredExample() File "./deferred_ex3.py", line 90, in deferredExample d.callback("success") File "/home/slyphon/Projects/Twisted/trunk/twisted/internet/defer.py", line 243, in callback self._startRunCallbacks(result) File "/home/slyphon/Projects/Twisted/trunk/twisted/internet/defer.py", line 312, in _startRunCallbacks self._runCallbacks() --- <exception caught here> --- File "/home/slyphon/Projects/Twisted/trunk/twisted/internet/defer.py", line 328, in _runCallbacks self.result = callback(self.result, *args, **kw) File "./deferred_ex3.py", line 34, in failAtHandlingResult raise RuntimeError, "whoops! we encountered an error" exceptions.RuntimeError: whoops! we encountered an error callback 3 got result: okay, continue on
addBoth: the deferred version of finally
Now we see how deferreds do finally, with .addBoth. The callback that gets added as addBoth will be called if the result is a failure or non-failure. We'll also see in this example, that our doThisNoMatterWhat() method follows a common idiom in deferred callbacks by acting as a passthru, returning the value that it received to allow processing the chain to continue, but appearing transparent in terms of the result.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ Now we'll see what happens when you use 'addBoth'. """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) return "okay, continue on" def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def doThisNoMatterWhat(arg): Counter.num += 1 print "both %s" % (Counter.num,) print "\tgot argument %r" % (arg,) print "\tdoing something very important" # we pass the argument we received to the next phase here return arg def behindTheScenes(result): # equivalent to d.callback(result) if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback try: result = failAtHandlingResult(result) except: result = failure.Failure() else: # ---- errback pass # ---- this is equivalent to addBoth(doThisNoMatterWhat) if not isinstance(result, failure.Failure): try: result = doThisNoMatterWhat(result) except: result = failure.Failure() else: try: result = doThisNoMatterWhat(result) except: result = failure.Failure() if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() def deferredExample(): d = defer.Deferred() d.addCallback(handleResult) d.addCallback(failAtHandlingResult) d.addBoth(doThisNoMatterWhat) d.addErrback(handleFailure) d.callback("success") if __name__ == '__main__': behindTheScenes("success") print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample()
callback 1 got result: success callback 2 got result: yay! handleResult was successful! about to raise exception both 3 got argument <twisted.python.failure.Failure exceptions.RuntimeError> doing something very important errback we got an exception: Traceback (most recent call last): --- <exception caught here> --- File "/home/slyphon/Projects/Twisted/trunk/twisted/internet/defer.py", line 326, in _runCallbacks self.result = callback(self.result, *args, **kw) File "./deferred_ex4.py", line 32, in failAtHandlingResult raise RuntimeError, "whoops! we encountered an error" exceptions.RuntimeError: whoops! we encountered an error
You can see that the errback is called, (and consequently, the failure is trapped). This is because doThisNoMatterWhat method returned the value it received, a failure.
addCallbacks: decision making based on previous success or failure
As we've been seeing in the examples, the callback is a pair of callback/errback. Using addCallback or addErrback is actually a special case where one of the pair is a pass statement. If you want to make a decision based on whether or not the previous result in the chain was a failure or not (which is very rare, but included here for completeness), you use addCallbacks. Note that this is not the same thing as an addCallback followed by an addErrback.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ Now comes the more nuanced addCallbacks, which allows us to make a yes/no (branching) decision based on whether the result at a given point is a failure or not. """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) return "okay, continue on" def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def yesDecision(result): Counter.num += 1 print "yes decision %s" % (Counter.num,) print "\twasn't a failure, so we can plow ahead" return "go ahead!" def noDecision(result): Counter.num += 1 result.trap(RuntimeError) print "no decision %s" % (Counter.num,) print "\t*doh*! a failure! quick! damage control!" return "damage control successful!" def behindTheScenes(result): if not isinstance(result, failure.Failure): # ---- callback try: result = failAtHandlingResult(result) except: result = failure.Failure() else: # ---- errback pass # this is equivalent to addCallbacks(yesDecision, noDecision) if not isinstance(result, failure.Failure): # ---- callback try: result = yesDecision(result) except: result = failure.Failure() else: # ---- errback try: result = noDecision(result) except: result = failure.Failure() if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass # this is equivalent to addCallbacks(yesDecision, noDecision) if not isinstance(result, failure.Failure): # ---- callback try: result = yesDecision(result) except: result = failure.Failure() else: # ---- errback try: result = noDecision(result) except: result = failure.Failure() if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() def deferredExample(): d = defer.Deferred() d.addCallback(failAtHandlingResult) d.addCallbacks(yesDecision, noDecision) # noDecision will be called d.addCallback(handleResult) # - A - d.addCallbacks(yesDecision, noDecision) # yesDecision will be called d.addCallback(handleResult) d.addErrback(handleFailure) d.callback("success") if __name__ == '__main__': behindTheScenes("success") print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample()
callback 1 got result: success about to raise exception no decision 2 *doh*! a failure! quick! damage control! callback 3 got result: damage control successful! yes decision 4 wasn't a failure, so we can plow ahead callback 5 got result: go ahead!
Notice that our errback is never called. The noDecision method returns a non-failure so processing continues with the next callback. If we wanted to skip the callback at "- A -" because of the error, but do some kind of processing in response to the error, we would have used a passthru, and returned the failure we received, as we see in this next example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ Now comes the more nuanced addCallbacks, which allows us to make a yes/no (branching) decision based on whether the result at a given point is a failure or not. here, we return the failure from noDecisionPassthru, the errback argument to the first addCallbacks method invocation, and see what happens. """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) return "okay, continue on" def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def yesDecision(result): Counter.num += 1 print "yes decision %s" % (Counter.num,) print "\twasn't a failure, so we can plow ahead" return "go ahead!" def noDecision(result): Counter.num += 1 result.trap(RuntimeError) print "no decision %s" % (Counter.num,) print "\t*doh*! a failure! quick! damage control!" return "damage control successful!" def noDecisionPassthru(result): Counter.num += 1 print "no decision %s" % (Counter.num,) print "\t*doh*! a failure! don't know what to do, returning failure!" return result def behindTheScenes(result): if not isinstance(result, failure.Failure): # ---- callback try: result = failAtHandlingResult(result) except: result = failure.Failure() else: # ---- errback pass # this is equivalent to addCallbacks(yesDecision, noDecision) if not isinstance(result, failure.Failure): # ---- callback try: result = yesDecision(result) except: result = failure.Failure() else: # ---- errback try: result = noDecisionPassthru(result) except: result = failure.Failure() if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass # this is equivalent to addCallbacks(yesDecision, noDecision) if not isinstance(result, failure.Failure): # ---- callback try: result = yesDecision(result) except: result = failure.Failure() else: # ---- errback try: result = noDecision(result) except: result = failure.Failure() if not isinstance(result, failure.Failure): # ---- callback try: result = handleResult(result) except: result = failure.Failure() else: # ---- errback pass if not isinstance(result, failure.Failure): # ---- callback pass else: # ---- errback try: result = handleFailure(result) except: result = failure.Failure() def deferredExample(): d = defer.Deferred() d.addCallback(failAtHandlingResult) # noDecisionPassthru will be called d.addCallbacks(yesDecision, noDecisionPassthru) d.addCallback(handleResult) # - A - # noDecision will be called d.addCallbacks(yesDecision, noDecision) d.addCallback(handleResult) # - B - d.addErrback(handleFailure) d.callback("success") if __name__ == '__main__': behindTheScenes("success") print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample()
callback 1 got result: success about to raise exception no decision 2 *doh*! a failure! don't know what to do, returning failure! no decision 3 *doh*! a failure! quick! damage control! callback 4 got result: damage control successful!
Two things to note here. First, "- A -" was skipped, like we wanted it to, and the second thing is that after "- A -", noDecision is called, because it is the next errback that exists in the chain. It returns a non-failure, so processing continues with the next callback at "- B -", and the errback at the end of the chain is never called
Hints, tips, common mistakes, and miscellaney
The deferred callback chain is stateful
A deferred that has been called back will call its addCallback and addErrback methods as appropriate in the order they are added, when they are added. So we see in the following example, deferredExample1 and deferredExample2 are equivalent. The first sets up the processing chain beforehand and then executes it, the other executes the chain as it is being constructed. This is because deferreds are stateful.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util """ The deferred callback chain is stateful, and can be executed before or after all callbacks have been added to the chain """ class Counter(object): num = 0 def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) f.trap(RuntimeError) def handleResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) return "yay! handleResult was successful!" def failAtHandlingResult(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) print "\tabout to raise exception" raise RuntimeError, "whoops! we encountered an error" def deferredExample1(): # this is another common idiom, since all add* methods # return the deferred instance, you can just chain your # calls to addCallback and addErrback d = defer.Deferred().addCallback(failAtHandlingResult ).addCallback(handleResult ).addErrback(handleFailure) d.callback("success") def deferredExample2(): d = defer.Deferred() d.callback("success") d.addCallback(failAtHandlingResult) d.addCallback(handleResult) d.addErrback(handleFailure) if __name__ == '__main__': deferredExample1() print "\n-------------------------------------------------\n" Counter.num = 0 deferredExample2()
callback 1 got result: success about to raise exception errback we got an exception: Traceback (most recent call last): --- <exception caught here> --- File "/home/slyphon/Projects/Twisted/trunk/twisted/internet/defer.py", line 326, in _runCallbacks self.result = callback(self.result, *args, **kw) File "./deferred_ex7.py", line 35, in failAtHandlingResult raise RuntimeError, "whoops! we encountered an error" exceptions.RuntimeError: whoops! we encountered an error ------------------------------------------------- callback 1 got result: success about to raise exception errback we got an exception: Traceback (most recent call last): --- <exception caught here> --- File "/home/slyphon/Projects/Twisted/trunk/twisted/internet/defer.py", line 326, in _runCallbacks self.result = callback(self.result, *args, **kw) File "./deferred_ex7.py", line 35, in failAtHandlingResult raise RuntimeError, "whoops! we encountered an error" exceptions.RuntimeError: whoops! we encountered an error
This example also shows you the common idiom of chaining calls to addCallback and addErrback.
Don't call .callback() on deferreds you didn't create!
It is an error to reinvoke deferreds callback or errback method, therefore if you didn't create a deferred, do not under any circumstances call its callback or errback. doing so will raise an exception
Callbacks can return deferreds
If you need to call a method that returns a deferred within your callback chain, just return that deferred, and the result of the secondary deferred's processing chain will become the result that gets passed to the next callback of the primary deferreds processing chain
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
#!/usr/bin/env python # Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. from twisted.internet import defer from twisted.python import failure, util class Counter(object): num = 0 let = 'a' def incrLet(cls): cls.let = chr(ord(cls.let) + 1) incrLet = classmethod(incrLet) def handleFailure(f): print "errback" print "we got an exception: %s" % (f.getTraceback(),) return f def subCb_B(result): print "sub-callback %s" % (Counter.let,) Counter.incrLet() s = " beautiful!" print "\tadding %r to result" % (s,) result += s return result def subCb_A(result): print "sub-callback %s" % (Counter.let,) Counter.incrLet() s = " are " print "\tadding %r to result" % (s,) result += s return result def mainCb_1(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) result += " Deferreds " d = defer.Deferred().addCallback(subCb_A ).addCallback(subCb_B) d.callback(result) return d def mainCb_2(result): Counter.num += 1 print "callback %s" % (Counter.num,) print "\tgot result: %s" % (result,) def deferredExample(): d = defer.Deferred().addCallback(mainCb_1 ).addCallback(mainCb_2) d.callback("I hope you'll agree: ") if __name__ == '__main__': deferredExample()
callback 1 got result: I hope you'll agree: sub-callback a adding ' are ' to result sub-callback b adding ' beautiful!' to result callback 2 got result: I hope you'll agree: Deferreds are beautiful!
Conclusion
Deferreds can be confusing, but only because they're so elegant and simple. There is a lot of logical power that can expressed with a deferred's processing chain, and once you see what's going on behind the curtain, it's a lot easier to understand how to make use of what deferreds have to offer.


Server Client Interactions
This page documents the interactions between the Server and Client from the perspective of API calls and the program workflow. The purpose of this documentation is to give visual aids and specifications to help programmers understand the code.
Table of Contents #
Client-Registration #
The first, most basic workflow is client registration. This is where the client device connects to the server, sets up it's Docker shell, and the server adds the client to marketplace of available devices for rent.
Check-Expiration #
The client device governor (p2p-vps-client.js
) will periodically reach out to
the server to check its expiration date.
When the client device has reached it's expiration, it will destroy the current
Docker container and wipe any persistent storage. It will then re-register
with the server by going through the client registration
workflow above.
Client-Check-In #
The connect-client.js
application running inside the Client Docker container is
responsible for establishing a reverse SSH connection with the server. It is also
responsible for sending a heart beat (or check-in signal) to the server to indicate
that it is connected to the network, and the software inside the Docker container
is running correctly.


MBS visits Riyadh Motor Show in Janadriyah
RIYADH — Crown Prince Muhammad Bin Salman, deputy premier and minister of defense, visited on Monday the Riyadh Motor Show in Janadriyah.
The international exhibition for motor vehicles is the most influential automotive show in the region that displays the latest modern passenger and commercial cars and other motor vehicles from around the world.
The auctioning of the classic cars is one of the major attractions of the show, one of the ongoing events of the Riyadh Season zones.
A car of the future called “Car 2030” launched on the first day of the Riyadh Motor Show in Janadriyah was sold on Saturday in a public auction for SR3,204,500.
The Riyadh Motor Show is part of various activities and entertainment shows presented by Riyadh Season, a unique exhibition featuring more than 1,200 classic and rare cars, attracted thousands of enthusiasts to Janadriyah on the northern outskirts of Riyadh. — Photos by Bandar Algaloud


The Bayesian view of the problem:
$$ p(x | y) \propto p(y | x) \ p(x) $$
$p(y | x)$ is the data likelihood, which contains the physics
$p(x)$ is the prior knowledge on the solution.
With these concepts in hand we can:
Estimate for instance the Maximum A Posteriori solution:
$$\hat{x} = \arg\max\limits_x \ \log p(y \ | \ x) + \log p(x)$$
Estimate from the full posterior p(x|y) with MCMC or Variational Inference methods.
How do you choose the prior ?
Classical examples of signal priors
Sparse
$$ \log p(x) = \parallel \mathbf{W} x \parallel_1 $$
Gaussian
$$ \log p(x) = x^t \mathbf{\Sigma^{-1}} x $$
Total Variation
$$ \log p(x) = \parallel \nabla x \parallel_1 $$
But what about this?
$\Longrightarrow$ Prior in the form of numerical simulations.
Can we use Deep Learning to embed simulation-driven priors within a physical Bayesian model?
The score is all you need!
Whether you are looking for the MAP or sampling with HMC or MALA, you
only need access to the score of the posterior:
$$\frac{\color{orange} d \color{orange}\log \color{orange}p\color{orange}(\color{orange}x \color{orange}|\color{orange} y\color{orange})}{\color{orange}
d
\color{orange}x}$$
The score of the full posterior is simply:
$$\nabla_x \log p(x |y) = \underbrace{\nabla_x \log p(y |x)}_{\mbox{known}} \quad + \quad \underbrace{\nabla_x \log p(x)}_{\mbox{can be learned}}$$
$\Longrightarrow$ all we have to do is model/learn the score of the prior.
Neural Score Estimation by Denoising Score Matching
Denoising Score Matching: An optimal Gaussian denoiser learns the score of a given distribution.
If $x \sim \mathbb{P}$ is corrupted by additional Gaussian noise $u \in \mathcal{N}(0, \sigma^2)$ to yield
$$x^\prime = x + u$$
Let's consider a denoiser $r_\theta$ trained under an $\ell_2$ loss:
$$\mathcal{L}=\parallel x - r_\theta(x^\prime, \sigma) \parallel_2^2$$
We use a very standard residual UNet, and we adopt a residual
score matching loss:
$$ \mathcal{L}_{DSM} = \underset{\boldsymbol{x} \sim P}{\mathbb{E}} \underset{\begin{subarray}{c}
\boldsymbol{u} \sim \mathcal{N}(0, I) \\
\sigma_s \sim \mathcal{N}(0, s^2)
\end{subarray}}{\mathbb{E}} \parallel \boldsymbol{u} + \sigma_s \boldsymbol{r}_{\theta}(\boldsymbol{x} + \sigma_s \boldsymbol{u}, \sigma_s) \parallel_2^2$$
$\Longrightarrow$ direct estimator of the score $\nabla \log p_\sigma(x)$
The likelihood term (and its score) are known analytically.
There is no close form expression for the full non-Gaussian prior of the convergence.
However:
We do have an analytic prior on its 2pt function, and that prior is accurate on large scales.
$$p_{th}(\boldsymbol{\kappa}) = \frac{1}{ \sqrt{ \det 2 \pi \boldsymbol{S}}} \exp \left( -\frac{1}{2} \boldsymbol{\kappa}^\dagger \boldsymbol{S}^{-1} \boldsymbol{\kappa} \right)$$
where $\mathbf{S}$ is the theoretical power spectrum of the convergence.
We do have access to samples of full prior through simulations.
Learning a Hybrid score: theoretical Gaussian on large scale, data-driven on small scales using N-body simulations.
$$\underbrace{\nabla_{\boldsymbol{\kappa}} \log p(\boldsymbol{\kappa})}_\text{full prior} = \underbrace{\nabla_{\boldsymbol{\kappa}} \log p_{th}(\boldsymbol{\kappa})}_\text{gaussian prior} +
\underbrace{\boldsymbol{r}_\theta(\boldsymbol{\kappa}, \nabla_{\boldsymbol{\kappa}} \log p_{th}(\boldsymbol{\kappa}))}_\text{learned residuals}$$
Illustration on MassiveNuS simulations
Probabilistic Mass-Mapping of the HST COSMOS field
Prior learned from MassiveNuS at fiducial cosmology (320x320 maps at 0.4 arcsec resolution).
Known massive X-ray clusters indicated with crosses, along with their redshifts, right pannel shows cutouts of central
cluster from multiple posterior samples.
Uncertainty quantification in Magnetic Resonance Imaging (MRI)
Ramzi, Remy, Lanusse et al. 2020
$$\boxed{y = \mathbf{M} \mathbf{F} x + n}$$
$\Longrightarrow$ We can see which parts of the image are well constrained by data, and which regions are uncertain.
Takeaways
Hybrid physical/deep learning Bayesian modeling
Using a Bayesian approach has great advantages: model-based physical interpretation & uncertainty quantification.
Explicit likelihood, uses of all of our physical knowledge.
$\Longrightarrow$ The method can be applied for varying PSF, noise, or even different instruments!
Deep generative models can be used to provide data driven priors.
$\Longrightarrow$ Embed prior only accessible from samples (e.g. numerical simulations).
Neural Score Estimation is a scalable approach to learn a prior score.
We implemented the "ultimate mass-mapping method"
$\Longrightarrow$ Recovered the best convergence map of the COSMOS field to date.


RIEN NE VA PLUS
Reviewed by Harvey Karten, Ph.D. New Yorker Films Director: Claude Chabrol Writer: Claude Chabrol Cast: Isabelle Huppert, Michel Serrault, Francois Cluzet, Jean-Francois Balmer, Jackie Berroyer, Jean Benguigui, Mony Dalmes, Thomas Chabrol, Greg Germain, Nathalie Kousnetzoff
Americans are not comfortable with age differences. If an older man with a hint of gray in his sideburns dines with a much younger woman, the public is likely to say, "Aha: boss having a fling with his secretary." The French are different. A man and woman may have a relationship filled with gaiety, earthy romance, and game-playing, while outsiders peering in may not necessarily guess the nature of the affiliation. Claude Chabrol plays with this idea in his fiftieth film, one which takes a marked departure form his recent, bloody works like "La Ceremonie." The politics is still there. The great sixty-eight-year old French director still likes to disturb the complacent bourgeoisie, but with "The Swindle" he is more interested in power balances within couples, specifically between the youthful and earthy Betty (Isabelle Huppert) and the considerably older Victor (Michel Serrault) to whom she is intensely loyal and loving. Money, that is, capitalism, has a way of interfering with pure connections like theirs, turning heretofore devoted human beings into manipulative beasts, each now willing to use the other as prey. This time around, Chabrol plumbs his characters for comic depth rather than homicidal passions: his 50th film is in no way the epic which the public had expected of him but is instead a delightful, feathery comedy.
The story opens as the two grifters, Betty and Victor, take on another victim in their role as middle-range swindlers, one which has provided the with a comfortable living and a considerable amount of fun. A woman of many disguises and fluid identity, Betty has donned a long black wig to seduce a conventioneer in the gaming room of a French hotel. Having previously drugged his whiskey, she waits until he passes out on the bed and then, together with her partner goes through the man's wallet, leaving him enough cash to think that nothing criminal has happened. She does, however, manage to capture his signature and with it writes a sizable check to a dummy company.
Weary of such moderate, low-key exercises, she announces to Victor that she has been planning a much larger sting, one which would result in their snatching of five million Swiss francs from a young and handsome man, Maurice (Francois Cluzet) who is ripping off the mob. After romancing him in the breathtaking Swiss ski resort of Sils- Maria, she flies with him and his fortune to Guadeloupe where she may or may not have been scheming to double- cross Maurice and/or Victor. Chabrol keeps us guessing, making us marvel at Betty's ability to orchestrate the relationship between the two men in her lives. Just when we are sure she has make a genuine romantic attachment with Maurice we are spun around, positive that she remains loyal to her long-term partner. What happens when Victor and Betty go off the deep end--get into a racket that's out of their traditional territory of middle-level wheeling and dealing--their connection and their very lives are at stake.
Chabrol, I believe, would like us to accept this congenial work on various levels, while even on the simplest plane it is a charming story. We love to watch Victor seething with envy at noting the affection that Betty is showing to the younger Maurice. For all his professionalism, Victor is unable to get this woman out of his mind, which makes us wonder all the more just what they are to each other. On yet another surface, Chabrol wants to show us what happens when people abandon the ancient Greek ideal of moderation: when they carry on to excess because of greed and envy they are tampering with the gods. On the highest level, he appears to be making a transcendent statement about the nature of people. They are fluid, changeable--especially women. Just as Betty throws off one wig to take on a wholly new identity, so can women in all their mystery keep us poor men in the dark about who they really are. Chabrol fans will have a fine time guessing at the allusions the director makes to some of his many previous films, works he began in 1958 with "Le Beau Serge," and "Les Cousins" and continued for the next forty years, including "The Story of Women," the not very successful "Madame Bovary" and the violent "La Ceremonie."
Michel Serrault has been acting since 1954 and Ms. Huppert since 1976. The seventy-year-old actor is known to American audiences best for his poignant portrait of the effeminate Albin in Edouard Molinaro's "La Cage aux Folles." He and the forty-three year old Huppert have never before performed together, yet they mesh luminously. "The Swindlers" illustrates the way that comedy is serious business, divulging remarkable intelligence to viewers about the human condition.
Not Rated. Running Time: 105 minutes. (C) 1998 Harvey Karten
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


ZachZachary grew up in Hawaii, and was a medic in the Army. After reintegrating, he worked in warehouse and minor construction positions before finding his interest in computers. After going to Leeward Community College for an Associate's in Computer Science and learning he wasn't learning the things that interested him about computers, he discovered the Code Fellows program. He dropped out, and immediately enrolled in Code Fellows. His goal in Code Fellows is to learn the skills to build tools and applications to help solve real world problems.


class Users extends User
Methods
| integer |
getId()
Get id |
|
| Users |
__construct()
Set FIO |
Details
at line 34
public integer
getId()
Get id
at line 47
public Users
__construct()
Set FIO


Sign in / Sign out
Donor Endpoints
Charity Endpoints
Endowment endpoints
Payment Account Endpoints
Endowment Subscription Endpoints
Wish Endpoints


|
Specifies a non-negative value indicating the width of the 3-D border drawn around active elements.
An element (a widget or portion of a widget) is active if the mouse cursor is positioned over the element and pressing a mouse button will cause some action to occur.
The value may have any of the forms acceptable to Tk_GetPixels. This option is typically only available in widgets displaying more than one element at a time (e.g. menus but not buttons).
© Author
| Home
| Sitemap
|


Toggle navigation
Galvanize Delivers
Order Delivery
Menu
Royale with Cheese
$8.99
ADD TO ORDER
Arugula Pie
$11.99
ADD TO ORDER
Smoked Swine
$14.99
ADD TO ORDER
Ice Cream Biscut
$7.99
ADD TO ORDER
Order
Item
Price
Subtotal
$0.00
Tax
$0.00
Total
$0.00
Name
Phone Number
Address
PLACE ORDER
Thank you! Your order has been placed.
Oops! Please complete your order.
Galvanize Delivers
Fine Dining, Delivered.
Home
Order Delivery


$().SPServices.SPDisplayRelatedInfo
SPDisplayRelatedInfo is a function in the jQuery Library for SharePoint Web Services that lets you display information which is related to the selection in a dropdown. This can really bring your forms to life for users: rather than just selecting bland text values, you can show them images and links that are related to their choices.
The SPDisplayRelatedInfo function works like this:
NOTE: This function is only meant to be used on the NewForm or EditForm; it works when a dropdown's value is changed.
Tip: If you don't want to see the column headers, pass in ms-hidden for headerCSSClass. (This is a CSS class in core.css which sets display: none.)
Here is an example of the form where you want to use SPDisplayRelatedInfo: In this example, I have a list called Systems, which has three columns:
columnName
The DisplayName of the column in the form
relatedWebURL
The URL of the Web (site) which contains the relatedList. If not specified, the current site is used. Examples would be: "/", "/Accounting", "/Departments/HR", etc. Note: It's always best to use relative URLs.
relatedList
The name or GUID of the list which contains the related information. If you choose to use the GUID, it should look like: "{E73FEA09-CF8F-4B30-88C7-6FA996EE1706}". Note also that if you use the GUID, you do not need to specify the relatedWebURL if the list is in another site.
relatedListColumn
The StaticName of the column in the relatedList
relatedColumns
An array of StaticNames of related columns to display
displayFormat
The format to use in displaying the related information. The default is "table". The displayFormat takes one of two options:
headerCSSClass
If specified, the CSS class for the table headers. The default is "ms-vh2".
rowCSSClass
If specified, the CSS class for the table cells. The default is "ms-vb".
numChars
If used on an input column (not a dropdown), no matching will occur until at least this number of characters has been entered. The default is 0.
matchType
If used on an input column (not a dropdown), type of match. Can be any valid CAML comparison operator, most often "Eq" or "BeginsWith". The default is "Eq".
CAMLQuery
The CAMLQuery option allows you to specify an additional filter on the relationshipList. The additional filter will be
CAMLQuery: "<Eq><FieldRef Name='Status'/><Value Type='Text'>Active</Value></Eq>"
matchOnId
By default, we match on the lookup's text value. If matchOnId is true, we'll match on the lookup id instead. The default value is false.
completefunc
If specified, the completefunc will be called each time there is a change to parentColumn. Potential uses for the completefunc: consistent default formatting overrides, additional lookup customizations, image manipulations, etc. You can pass your completefunc in either of these two ways:
completefunc: function() {
...do something...
},
or
completefunc: doSomething, // Where doSomething is the name of your function
debug
Setting debug: true
indicates that you would like to receive messages if anything obvious is wrong with the function call, like using a column name which doesn't exist. I call this debug mode.
$().SPServices.SPDisplayRelatedInfo({
columnName: "System",
relatedList: "Systems",
relatedListColumn: "Title",
relatedColumns: ["System_x0020_Image", "Lead_x0020_Sales_x0020_Rep"],
displayFormat: "list"
});
Here I’m asking SPDisplayRelatedInfo to show me the values in the System_x0020_Image
and Lead_x0020_Sales_x0020_Rep
columns (these are the StaticNames of the list columns as opposed to the DisplayNames in the Systems
list under the System
column in my form using the list
display format where the System value matches the
Titlevalue in the
Systems` list. I’m just taking the default CSS classes for the example. As you can see, you can pass in any CSS class you’d like to make the SPDisplayRelatedInfo output match your site branding.
In this example, I'm displaying some information about the Region
. To make the output look better, I'm doing a little post-processing on the Total_x0020_Sales
column. You’ll see that I’m both pre-pending the value with “$” and right justifying it. In my case, the column is Region
and the Total_x0020_Sales
column is the 4th one, so I’m using :nth-child(4)
.
$().SPServices.SPDisplayRelatedInfo({
columnName: "Region",
relatedWebURL: "/Intranet/JQueryLib",
relatedList: "Regions",
relatedListColumn: "Title",
relatedColumns: ["ID", "Country", "Title", "Total_x0020_Sales"],
displayFormat: "table",
completefunc: addDollarSigns,
debug: true
});
function addDollarSigns() {
$("#SPDisplayRelatedInfo_Region td:nth-child(4)").prepend("$").css("textAlign", "right");
}


Just put your image size after our URL and you'll get a placeholder.
For example:
tkirplaceholder.org/list/360x230
tkirplaceholder.org/list?size=360x230
Set pictures theme
tkirplaceholder.org/list/360x230/sports
tkirplaceholder.org/list?size=360x230&theme=sports
returns JSON:
{{res | json}}


[1]
that said the room was lovely comfy beds so we had a good nights sleep .
[2]
minutes early with quite a few bags from the car park which is tiny .


19.Environment Canada. National Inventory Report 2009–2013. Greenhouse Gas Sources and
Sinks in Canada. The Canadian Government’s Submission to the UN Framework Convention
on Climate Change. Part 1. 2015.
http://publications.gc.ca/collections/collection_2016/eccc/En81-4-2013-1-eng.pdf. Accessed 15 Nov 2017.


[bug] Separate global menu
-
anonymous
I have Synergy's preferences set so that the 'show global menu as a separate menu item' option is not enabled. However, upon startup I always get a separate global menu item. I have to open synergy's prefs, enable the option & apply, then disable it and apply for the global menu to disappear.
-
Greg Hurrell
I can't reproduce that here. Are you sure that you don't have an older version of Synergy installed on your system somewhere? It's possible you installed the new one into ~/Library/PreferencePanes/ and left an older copy behind in /Library/PreferencePanes/...
-
anonymous
Nope, all I can find is v1.0a7 in ~/Library/PreferencePanes. Nothing installed in /Library (as I would expect since I used your automatic installer). Not a big deal so I'll wait and see if it persists across the next version.
-
Greg Hurrell
Quote: Nope, all I can find is v1.0a7 in ~/Library/PreferencePanes. Nothing installed in /Library (as I would expect since I used your automatic installer). Not a big deal so I'll wait and see if it persists across the next version.
You could also email me your preferences file (to<EMAIL_ADDRESS>and I will take a look at it. The file is ~/Library/Preferences/org.wincent.Synergy.plist.
-
anonymous
Sent you my prefs file. Hope there's a clue in there somewhere.
-
Greg Hurrell
I tried your preferences file here and the problem occurred, so I immediately knew that we were dealing with a corrupt preferences file.
I've found the garbled entry, corrected it, and now it works.
Have sent it back to you via email.
Reply
This topic is now closed.


{% block dir_head %}{% endblock %} {% block cal_head %}{% endblock %}
Send an emergency alert to active team. All form fields are required.
Send a message to send the team home. All form fields are required.


static.Rd
Create a static plot based on rasterly
object.
This function allows users to add axes, legends and other descriptive details when generating `rasterly` objects.
rasterlyGrob( rasterlyObj, xlim = NULL, ylim = NULL, xlab = NULL, ylab = NULL, main = NULL, sub = NULL, interpolate = FALSE, axes = TRUE, legend = TRUE, legend_label = NULL, legend_layer = 1, legend_main = NULL, axes_gpar = grid::gpar(col = "black", cex = 1), label_gpar = grid::gpar(col = "black", cex = 1), main_gpar = grid::gpar(col = "black", cex = 1.5), legend_gpar = grid::gpar(col = "black", cex = 1.5), name = NULL, gp = NULL, vp = NULL ) grid.rasterly( rasterlyObj, interpolate = FALSE, axes = TRUE, xlim = NULL, ylim = NULL, xlab = NULL, ylab = NULL, main = NULL, sub = NULL, legend = TRUE, legend_label = NULL, legend_layer = 1, legend_main = NULL, axes_gpar = grid::gpar(col = "black", cex = 1), label_gpar = grid::gpar(col = "black", cex = 1), main_gpar = grid::gpar(col = "black", cex = 1.5), legend_gpar = grid::gpar(col = "black", cex = 1.5), name = NULL, gp = NULL, vp = NULL, ... ) # S3 method for rasterly plot( x, y = NULL, xlim = NULL, ylim = NULL, xlab = NULL, ylab = NULL, main = NULL, legend_main = NULL, sub = NULL, interpolate = FALSE, axes = TRUE, legend = TRUE, legend_label = NULL, legend_layer = 1, new.page = TRUE, ... ) # S3 method for rasterly print(x, ...)
| rasterlyObj | A |
|---|---|
| xlim | Numeric; the x limits (x1, x2) of the plot. Default is |
| ylim | Numeric; the y limits (y1, y2) of the plot. Default is |
| xlab | Character; the label to be used for the |
| ylab | Character; the label to be used for the |
| main | Character; the title to be used for the plot. Default is |
| sub | sub Character; a subtitle for the plot. Default is |
| interpolate | Logical. Linearly interpolates the image if |
| axes | Logical; should axes be drawn? Default is |
| legend | Logical. Show a figure legend? Default is |
| legend_label | Character. The label to apply to the figure legend. Default is |
| legend_layer | Numeric. Specify the layer level within the |
| legend_main | Character. The main title to use within the figure legend. The default is |
| axes_gpar | Object of class |
| label_gpar | Object of class |
| main_gpar | Object of class |
| legend_gpar | Object of class |
| name | Character. An identifier used to locate the |
| gp | A |
| vp | Object of class |
| ... | Other arguments to modify the display. |
| x | A |
| y | NULL, will be ignored. |
| new.page | display on a new page or not. |
We provide three functions to produce static graphics, which is based on the API of grid
, plot
and print
.
grid
: The rasterlyGrob
and grid.rasterly
are the most flexible data structure.
These functions produce a **grob
** object. Users can modify the existing display by the functions provided by grid
.
plot.rasterly
: The usage of this S3 method is very similar to the classic plot
function.
Users can set axis limits via xlim
and ylim
, as well as the corresponding labels using xlab
and ylab
, among other attributes.
print.rasterly
: This S3 method returns only a basic image raster.
if(requireNamespace("grid")) { data <- data.frame(x = rnorm(1e6), y = rexp(1e6, 10)) # a rasterly object rasterlyObj <- data %>% rasterly(mapping = aes(x = x, y = y)) %>% rasterly_points() # Generate a grob rg <- rasterlyGrob(rasterlyObj) ## get the raster grob by `grid::getGrob()` grid::getGrob(rg, "raster") grid::grid.newpage() grid::grid.draw(rg) # or grid::grid.newpage() grid.rasterly(rasterlyObj) # or `plot` plot(rasterlyObj, xlab = "rnorm(1e6)", ylab = "rexp(1e6, 10)", main = "This is an arbitrary plot") # or simply print rasterlyObj ## it is equivalent to `print(rasterlyObj)` }


Palace confirms Prince Andrew will continue to work on Pitch@Palace scheme
by Edward ThicknesseBuckingham Palace this morning confirmed that Prince Andrew will continue to work on his Pitch@Palace initiative, as was first reported by City A.M. last night.
A source close to Pitch@Palace told City A.M. that it was "business as usual" at the programme, which connects entrepreneurs with investors.
This morning a number of businesses have expressed their support for the scheme, as the Duke was urged to give evidence to US authorities.
It comes after the Duke announced he would step back from public duties for the foreseeable future.
Main image credit: Getty


Most people have at least heard of Pokémon — Nintendo's ever-popular title — which asks players to travel a fictional world in order to collect every creature out there. But today's world is not the world of the 1990s: Nintendo and Niantic Labs have teamed up to let players catch Pokémon in the very world we live in, thanks to a combination of GPS, augmented reality, and dorky-cute graphics.
 That means instead of tapping or using a D-pad to tell your virtual avatar where to go to find Pokémon, you're actually walking. In the real world. Crazy, we know.
You may have stumbled onto this page knowing nothing about Pokémon. That's okay. You don't have to be a fan of the previous games or even know the lore to have fun with this game: While it may overtly promote itself as a game about catching Pokémon and battling, the real joy is exploring the real world with your friends, giggling while you check in at historical monuments disguised as PokéStops, and making new connections in your neighborhood with other would-be Pokétrainers.


New Jersey-based Obscure Sorrows Records was founded in 2020 with a mission of providing an open and liberating space for techno artists worldwide to tell their stories through music releases and podcasts not bounded by one strict sound of techno.
by MTZTGR
Born in Berlin only a few years shy of the wall falling, MTZTGR grew up in that energetic melting pot full of creative misfits, that was this city, his sound is dark and of chaotic beauty.
Sedric is a musician/producer and hybrid-performer. He loves exploring the deep, hypnotic, spherical and melodic sides of techno.
Aviatrix started out on the late night air waves playing an emotional mix of experimental, electronic, chillwave, nu-disco, and house music for New Brunswick, NJ-based 90.3FM in 2012. After building a radio audience her blending became more groove-based and she moved into live dance floor mixing of house and techno.
CØNTRUST of Aesthetic Depression.
The ecstasy is in full swing, the term consciousness is just now being defined for me.
I am at home between sweaty bodies and deep bass waves. Far from norms and rules,
this is just about us, the community, the big picture
22 year old DJ/Producer from New Jersey, USA, Bringing a high energy and aggressive mix. He experiments with different styles of deep atmospheric techno and hard techno in his mixes and live shows. Recently released an EP titled "Dreamer", which is a good representation of his personality.
Evis May is a Russian techno artist with guest shows at various Moscow clubs like WoW Club, DISSIDENT, ARTPLAY, Malevich Bar, Apocalypse Bar, Ruin, Ketch Up and others. She is a part of the Shift Moscow collective, Radar Moscow and Rave Atlas core member-representing the platform in Russia, and a music producer.


The robbed generations
"Children in care," writes Arthur Chesterfield-Evans (Herald, July 15), ``need governments prepared to learn from their past mistakes and failures."
How can the community and the Department of Community Services learn from the past when no-one bothers to ask how older state wards fared when released from wardship and were left to fend for themselves, without to this day any support services?
As former state wards we could tell you the devastating consequences that we, and many others, still live with today: such as the effects of abandonment, institutionalisation, emotional neglect, insecurity, minimal education and the lack of identity that results from loss of family.
Like the ``stolen generations" many state wards lost all contact with their family of origin and their ethnic and cultural background, directly through government intervention.
There is also the stigma of being a state ward, which has helped to silence the thousands of people who have grown up feeling that somehow it is their fault that nobody cares for them.
It's time that society acknowledged, and learnt from, the legacy that past state wards carry with them through their lives. Only then can we bring about the changes in the system which will prevent children in ``care" from entering the same damaging cycle.
Leonie Sheedy, John Murray, Ray Flett, Win Evans (80) July 18 Georges Hall.
Heaven-sent
The Bledisloe Cup match at the weekend demonstrated what I have been trying to tell my seven-year-old son Oliver for months that rugby union is a far superior game to rugby league.
Consider the similarities: both games use egg-shaped balls and oblong fields with H-shaped posts, and are played by large, hairy men with metal spikes on the bottom of their shoes. You can be injured, maimed or even killed in either code. Both games are referred to as ``footy", ``football" and even ``rugby". Both games attempt to extract the same qualities from its players courage, strength, speed, agility, strategic excellence and teamwork. And yet, consider the differences: one game actually achieves all this, the other doesn't come close. One game flows from one play to the next, with the phases building upon each other in orchestrated intensity; the other game is a stop-start succession of individual ``hit-ups".
But try explaining that to a seven-year-old. I couldn't, so I took him to the game on Saturday night and it was an experience neither of us will ever forget.
In the end, when Jonah scored in the corner a mere 25 metres from where we sat, I turned to look at my son's face, and I knew he understood.
One game is played in heaven. The other one ain't.
James Stevens,July 17 Korora.
Sanctionmonius
Having perceived George Speight as a frontman from early in the piece, not to mention being at a bit of a loss as to why the Australian media has forsaken the basic rule of following the money trail, your editorial opinion (July 15) that ``it's time for sanctions" causes me to ask against whom and/or what?
Three major industries, ostensibly of Fiji, come to mind.
Sanctions against the tourist industry would send Australian dollars elsewhere, but might not sit well with Australian capital investments of a higher order.
Much the same might be said about Fijian sugar and Australia's CSR.
The Australian sorry, Fijian garment industry would have to find another offshore island with equally low wages, but that'd be just outsourcing by another name.
All in all, a ban on footy players looks the safest bet, though that would have to be taken up with the great council of sportsmen.
Nope, it would have been far better to have followed the money trail and let the chips fall where they lie.
E.D. Webber, July 15 Blue Haven.
The Foreign Minister, Alexander Downer, says that sanctions against Fiji are inappropriate because they will cause harm to innocent Fijians and destroy Fiji's economy.
However, the Government supports the much more severe sanctions against Iraq which have killed hundreds of thousands of innocent people.
Why are Fijian civilians worth protecting while Iraqi civilians are not?
Phil Watson, July 18 Wheeler Heights.
Is it time to change the name of the Pacific to the Bellicose ocean?
Edgar Blau, July 15Avalon.

I'm no big fan of four-wheel drives (I think they are a menace) but would a bus have been better? Or a motorcycle? Another small car, so even more people are killed?
It is too easy to blame everybody and everything else. After all, inappropriate speed to the conditions is what kills and no amount of legislation or draconian speed limits will stop somebody going around a 35km/h corner at 60km/h.
Only adequate driver training on the road and in the classroom will address this problem. Keep the parents out of driver education leave it to the experts.
Charles Pauka, July 17 Castle Hill.
Switch solution
Perhaps the problems of anti-child and child care would be ameliorated if children were fitted with switches.
This, however, is not a complete solution as a child would probably cease growing while switched off, thus prolonging the problem.
Donald B. Taylor, July 13 Goonellabah.


Defines the initial capital for the back-test.
Initial capital for the back-test.
Updates the capital according to the traded value after executing the entry position.
Traded value at the time.
Updates the capital according to the traded value after executing the exit position.
Traded value at the time.
Generated using TypeDoc
Creates a back-test report.


back to main page
Search
Search
X_position
Y_position
Direction
X
Y
expand_less
mouse
expand_more
mouse
x1
mouse
x2
mouse
fullscreen
fullscreen_exit
space_bar


Patients can access a plethora of healthcare prices at no cost. Just submit your latest receipt from your doctor's visit to create an account and you're ready to go.
Your health information is important to us. As such, we make it a priority to keep you safe while using our platform. Through our privacy protection technology, nobody will be able to access your personal information, even if someone steals your account.
Hospitals can create accounts to interact with users and gather feedback on their services. Participating on our platform gives a powerful way for healthcare providers to connect with their users and learn from them.
You can start helping by sending your hospital receipts. Because our platform is powered by real data from real people, we need real experiences like yours to help yourself and others avoid spending unnecessary dollars during stressful times. You can help by doing just two things:


Currently working with Fleetway Inc. as a Junior Electrical Technologist
Advanced education on electrical systems and communication. Excelled in AutoCAD, Labview, RsLogix, and Arduino.
Focused on technical problem solving and electrical systems knowledge. Experienced with lab equiptment and diagnostic procedure.
Encouradged critical thinking, report writing, and public speaking.
My college program covered multiple subjects. I excel at:
Work on large scale projects as part of a national team using Agile. Write technical reports with user-friendly instructions.
Provided thechncial support and advice to global clients and collegues. Analyzed and resolved issues with both hardware and software.
Assisted with general purpose contracting in renovation, roofing, and landscaping. Experienced valuable hands-on experience in construction.
Completed government mandated training program and provincial license. Worked overnight shifts with no supervision watching video feeds from accross Canada. Dispatched patrol units. Used best judgement to analyze situations and determine possible threats.
Assisted customers with technical questions ranging from home computers to server hardware. Organized stock and displays while maintaining and optimizing the presentation of the store. Remained up to date on a multitude of computer technologies to assist in sales and troubleshooting (compute, storage, networking, security, etc).
There are many ways I enjoy investing my spare time. I enjoy hiking, camping, and kayaking or canoeing while occasionally working on my photography skills. At home I maintain a homelab where I spend time playing with virtualization and home automation.
I'm always open to suggestions on hobbies I may enjoy!
Personal Homelab


Impress header text
Creating Stunning Visualizations
Impress.js
Press Spacebar or Tab To Get Started
This Slide Moves From Left To Right
This Slide Moves From Right To Left
This Slide Moves From Right To Left and Bottom To Top
This Slide Moves Top To Bottom
This Slide Rotates Clockwise Around z-axis
This Slide Scales 3 Times
Away
Towards
| This will appear as the first list item. | |
| Second list item, and so on... |
Futher Towards
Visualization Slide Positions


Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.
SAP Concur partners with external payment providers for processing invoice payments. These payment providers are listed on the App Center and can integrate with the Invoice product by using the Invoice Pay APIs. Payment providers can get a list of all the payments authorized to be processed by them, and send back status of those payments.
Base URLs:
Code samples
# You can also use wget
curl -X GET /www.concursolutions.com/invoice/provider-payment/v4/payments \
-H 'Accept: application/json'
GET /www.concursolutions.com/invoice/provider-payment/v4/payments HTTP/1.1
Accept: application/json
const headers = {
'Accept':'application/json'
};
fetch('/www.concursolutions.com/invoice/provider-payment/v4/payments',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/www.concursolutions.com/invoice/provider-payment/v4/payments',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/www.concursolutions.com/invoice/provider-payment/v4/payments', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','/www.concursolutions.com/invoice/provider-payment/v4/payments', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("/www.concursolutions.com/invoice/provider-payment/v4/payments");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/www.concursolutions.com/invoice/provider-payment/v4/payments", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /invoice/provider-payment/v4/payments
Payment Providers can use this API to get details of payments marked to be paid by them
Example responses
200 Response
{
"payments": [
{
"invoices": [
{
"invoiceAmount": {
"amount": "string",
"currency": "str"
},
"invoiceId": "string",
"invoiceNumber": "string",
"notesToSupplier": "string",
"paymentAmount": {
"amount": "string",
"currency": "str"
}
}
],
"paymentDueDate": "2019-08-24",
"paymentId": "string",
"paymentMethod": "string",
"totalAmount": {
"amount": "string",
"currency": "str"
},
"vendor": {
"addressLine1": "string",
"addressLine2": "string",
"addressLine3": "string",
"buyerAccountNumber": "string",
"city": "string",
"countryCode": "string",
"countryName": "string",
"email": "string",
"firstName": "string",
"lastName": "string",
"phoneNumber": "string",
"postalCode": "string",
"state": "string",
"vendorAddrCode": "string",
"vendorCode": "string",
"vendorName": "string"
}
}
]
}
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | readPaymentResult |
| 401 | Unauthorized | Unauthorized | None |
| 403 | Forbidden | Forbidden | None |
| 404 | Not Found | Not Found | None |
Code samples
# You can also use wget
curl -X POST /www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId} \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
POST /www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId} HTTP/1.1
Content-Type: application/json
Accept: application/json
const inputBody = '{
"paidAmount": {
"amount": "string",
"currency": "str"
},
"paymentAdjustmentNotes": "string",
"paymentInitiationDate": "2019-08-24",
"paymentMethod": "ACH",
"paymentSettlementDate": "2019-08-24",
"providerReference": "string",
"status": "PAID",
"statusDate": "2019-08-24",
"statusMessage": "string",
"thirdPartyPaymentIdentifier": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'application/json'
};
fetch('/www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId}',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json'
}
result = RestClient.post '/www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
r = requests.post('/www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => 'application/json',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','/www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("/www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/www.concursolutions.com/invoice/provider-payment/v4/payments/{PaymentId}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /invoice/provider-payment/v4/payments/{PaymentId}
Payment Providers can use this API to update the status of payments made by them
Body parameter
{
"paidAmount": {
"amount": "string",
"currency": "str"
},
"paymentAdjustmentNotes": "string",
"paymentInitiationDate": "2019-08-24",
"paymentMethod": "ACH",
"paymentSettlementDate": "2019-08-24",
"providerReference": "string",
"status": "PAID",
"statusDate": "2019-08-24",
"statusMessage": "string",
"thirdPartyPaymentIdentifier": "string"
}
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| PaymentId | path | string | true | PaymentId |
| body | body | updatePayment | true | Payment |
Example responses
200 Response
{
"createdDate": "2019-08-24T14:15:22Z",
"lastModifiedDate": "2019-08-24T14:15:22Z",
"paidAmount": {
"amount": "string",
"currency": "str"
},
"paymentAdjustmentNotes": "string",
"paymentInitiationDate": "2019-08-24",
"paymentMethod": "ACH",
"paymentSettlementDate": "2019-08-24",
"providerReference": "string",
"status": "PAID",
"statusDate": "2019-08-24",
"statusMessage": "string",
"thirdPartyPaymentIdentifier": "string"
}
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | updatePaymentResult |
| 201 | Created | Created | None |
| 401 | Unauthorized | Unauthorized | None |
| 403 | Forbidden | Forbidden | None |
| 404 | Not Found | Not Found | None |
{
"amount": "string",
"currency": "str"
}
amount
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| amount | string | false | none | Amount. Maximum 20 characters. |
| currency | string | false | none | Currency Code. Maximum 3 characters. |
{
"invoiceAmount": {
"amount": "string",
"currency": "str"
},
"invoiceId": "string",
"invoiceNumber": "string",
"notesToSupplier": "string",
"paymentAmount": {
"amount": "string",
"currency": "str"
}
}
invoice
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| invoiceAmount | amount | false | none | none |
| invoiceId | string | false | none | Unique identifier of the invoice in SAP Concur. This can be used to get additional invoice information from other APIs. This is the same as paymentRequestID in other Invoice APIs. Maximum 20 characters. |
| invoiceNumber | string | false | none | Invoice Number. Maximum 50 characters. |
| notesToSupplier | string | false | none | Notes to the supplier contain remittance information that the buyer wants to provide to the supplier. Maximum 500 characters. |
| paymentAmount | amount | false | none | none |
{
"invoices": [
{
"invoiceAmount": {
"amount": "string",
"currency": "str"
},
"invoiceId": "string",
"invoiceNumber": "string",
"notesToSupplier": "string",
"paymentAmount": {
"amount": "string",
"currency": "str"
}
}
],
"paymentDueDate": "2019-08-24",
"paymentId": "string",
"paymentMethod": "string",
"totalAmount": {
"amount": "string",
"currency": "str"
},
"vendor": {
"addressLine1": "string",
"addressLine2": "string",
"addressLine3": "string",
"buyerAccountNumber": "string",
"city": "string",
"countryCode": "string",
"countryName": "string",
"email": "string",
"firstName": "string",
"lastName": "string",
"phoneNumber": "string",
"postalCode": "string",
"state": "string",
"vendorAddrCode": "string",
"vendorCode": "string",
"vendorName": "string"
}
}
payment
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| invoices | [invoice] | false | none | none |
| paymentDueDate | string(date) | false | none | The date by which the payment should be made. |
| paymentId | string | false | none | Unique identifier of the payment in SAP Concur. Maximum 36 characters. |
| paymentMethod | string | false | none | The value is always PAYPVD which means that the client wants to pay using a payment provider. Maximum 15 characters. |
| totalAmount | amount | false | none | none |
| vendor | vendor | false | none | none |
{
"payments": [
{
"invoices": [
{
"invoiceAmount": {
"amount": "string",
"currency": "str"
},
"invoiceId": "string",
"invoiceNumber": "string",
"notesToSupplier": "string",
"paymentAmount": {
"amount": "string",
"currency": "str"
}
}
],
"paymentDueDate": "2019-08-24",
"paymentId": "string",
"paymentMethod": "string",
"totalAmount": {
"amount": "string",
"currency": "str"
},
"vendor": {
"addressLine1": "string",
"addressLine2": "string",
"addressLine3": "string",
"buyerAccountNumber": "string",
"city": "string",
"countryCode": "string",
"countryName": "string",
"email": "string",
"firstName": "string",
"lastName": "string",
"phoneNumber": "string",
"postalCode": "string",
"state": "string",
"vendorAddrCode": "string",
"vendorCode": "string",
"vendorName": "string"
}
}
]
}
readPaymentResult
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| payments | [payment] | false | none | none |
{
"paidAmount": {
"amount": "string",
"currency": "str"
},
"paymentAdjustmentNotes": "string",
"paymentInitiationDate": "2019-08-24",
"paymentMethod": "ACH",
"paymentSettlementDate": "2019-08-24",
"providerReference": "string",
"status": "PAID",
"statusDate": "2019-08-24",
"statusMessage": "string",
"thirdPartyPaymentIdentifier": "string"
}
updatePayment
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| paidAmount | amount | false | none | none |
| paymentAdjustmentNotes | string | false | none | Payment adjustment notes sent by the payment provider. Maximum 255 characters. |
| paymentInitiationDate | string(date) | false | none | The date the payment was initiated. |
| paymentMethod | string | false | none | Payment method used by the payment provider. Required if the status is PAID, CHECK_PROCESSED, or CARD_SETTLED. |
| paymentSettlementDate | string(date) | false | none | The date the payment will be in the payees account. |
| providerReference | string | false | none | Unique identifier of the payment in the payment provider’s system. This will be used for internal troubleshooting. Maximum 100 characters. |
| status | string | true | none | Used to depict success, error or any other intermediate state, defined by SAP Concur. |
| statusDate | string(date) | true | none | The date that the payment provider recorded this status change. |
| statusMessage | string | false | none | Payment provider description of the status. Providers can supply any message. Maximum 255 characters. |
| thirdPartyPaymentIdentifier | string | false | none | Check number if the payment was done via check or trace number for ACH payments. Maximum 255 characters. |
| Property | Value |
|---|---|
| paymentMethod | ACH |
| paymentMethod | CHECK |
| paymentMethod | WIRE |
| paymentMethod | CARD |
| paymentMethod | OTHER |
| status | PAID |
| status | CANCELED |
| status | CARD_AUTHORIZED |
| status | CARD_EMAIL_SENT |
| status | CARD_SETTLED |
| status | CHECK_MAILED |
| status | CHECK_PRINTED |
| status | CHECK_PROCESSED |
| status | CHECK_VOIDED |
| status | PENDING_RETRIEVAL |
| status | PROCESSING |
| status | REJECTED |
| status | RETRIEVED |
| status | RETURNED |
{
"createdDate": "2019-08-24T14:15:22Z",
"lastModifiedDate": "2019-08-24T14:15:22Z",
"paidAmount": {
"amount": "string",
"currency": "str"
},
"paymentAdjustmentNotes": "string",
"paymentInitiationDate": "2019-08-24",
"paymentMethod": "ACH",
"paymentSettlementDate": "2019-08-24",
"providerReference": "string",
"status": "PAID",
"statusDate": "2019-08-24",
"statusMessage": "string",
"thirdPartyPaymentIdentifier": "string"
}
updatePaymentResult
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| createdDate | string(date-time) | false | none | The date the payment was created. |
| lastModifiedDate | string(date-time) | false | none | The date the payment was last modified. |
| paidAmount | amount | false | none | none |
| paymentAdjustmentNotes | string | false | none | Payment adjustment notes sent by the payment provider. Maximum 255 characters. |
| paymentInitiationDate | string(date) | false | none | The date the payment was initiated. |
| paymentMethod | string | false | none | Payment method used by the payment provider. Required if the status is PAID, CHECK_PROCESSED, or CARD_SETTLED. |
| paymentSettlementDate | string(date) | false | none | The date the payment will be in the payees account. |
| providerReference | string | false | none | Unique identifier of the payment in the payment provider’s system. Maximum 100 characters. |
| status | string | true | none | Used to depict success, error or any other intermediate state, defined by SAP Concur. |
| statusDate | string(date) | true | none | The date that the payment provider recorded this status change. |
| statusMessage | string | false | none | Payment provider description of the status. Providers can supply any message. Maximum 255 characters. |
| thirdPartyPaymentIdentifier | string | false | none | Check number if the payment was done via check or trace number for ACH payments. Maximum 255 characters. |
| Property | Value |
|---|---|
| paymentMethod | ACH |
| paymentMethod | CHECK |
| paymentMethod | WIRE |
| paymentMethod | CARD |
| paymentMethod | OTHER |
| status | PAID |
| status | CANCELED |
| status | CARD_AUTHORIZED |
| status | CARD_EMAIL_SENT |
| status | CARD_SETTLED |
| status | CHECK_MAILED |
| status | CHECK_PRINTED |
| status | CHECK_PROCESSED |
| status | CHECK_VOIDED |
| status | PENDING_RETRIEVAL |
| status | PROCESSING |
| status | REJECTED |
| status | RETRIEVED |
| status | RETURNED |
{
"addressLine1": "string",
"addressLine2": "string",
"addressLine3": "string",
"buyerAccountNumber": "string",
"city": "string",
"countryCode": "string",
"countryName": "string",
"email": "string",
"firstName": "string",
"lastName": "string",
"phoneNumber": "string",
"postalCode": "string",
"state": "string",
"vendorAddrCode": "string",
"vendorCode": "string",
"vendorName": "string"
}
vendor
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| addressLine1 | string | false | none | Vendor Address line 1. Maximum 255 characters. |
| addressLine2 | string | false | none | Vendor Address line 2. Maximum 255 characters. |
| addressLine3 | string | false | none | Vendor Address line 3. Maximum 255 characters. |
| buyerAccountNumber | string | false | none | Buyer Account Number. Maximum 50 characters. |
| city | string | false | none | Vendor Address City. Maximum 255 characters. |
| countryCode | string | false | none | Vendor Address Country Code. Maximum 2 characters. |
| countryName | string | false | none | Vendor Address Country Name. Maximum 64 characters. |
| string | false | none | Email Address. Maximum 255 characters. | |
| firstName | string | false | none | First Name. Maximum 255 characters. |
| lastName | string | false | none | Last Name. Maximum 255 characters. |
| phoneNumber | string | false | none | Phone Number. Maximum 25 characters. |
| postalCode | string | false | none | Vendor Address Postal Code. Maximum 20 characters. |
| state | string | false | none | Vendor Address State. Maximum 10 characters. |
| vendorAddrCode | string | false | none | Vendor Address Code. Maximum 64 characters. |
| vendorCode | string | false | none | Vendor Code. Maximum 32 characters. |
| vendorName | string | false | none | Vendor Name. Maximum 255 characters. |


Banner Section
A showcase of our most recent, exciting and awarded projects
Portfolio Section
Ignite Elections
Election Campaign
The Admiral
Newspaper
Golden Goods
Bakery Brand
Static Volumes
Music Mixer Project
Osmosis
Brewery Brand
On Track Fitness
Fitness Brand
Riddick Estates
Winery Brand
BVSC Brewing
Brand and Packaging


This course is designed to introduce you to the discipline of plant biology and increase your awareness and appreciation of the impact of plants on your daily lives. The first part of the course will present the fundamentals of botany to provide you with a basic understanding of plant form and function. The rest of the course will be devoted to a survey of historical, cultural, and economic aspects of botany and related fields. We will finish up with an examination of the role of plants as an integral part of the world's ecosystem.
The purpose of Biology 120 is to introduce you to the fascinating world of plants with an emphasis on the historical, cultural, and economic uses.
Levetin and McMahon, Plants and Society, 6th edition, McGraw-Hill. ISBN:<PHONE_NUMBER>221
| Week | Topic |
|---|---|
| 1 | Plants in Life and in History |
| 2 | Plant Anatomy and Physiology |
| 3 | Plant Genetics, Systematics, and Diversity |
| 4 | Plants and Dietary Needs |
| 5 | Grasses and Legumes |
| 6 | Starches and Carbohydrates: Feeding the Hungry World |
| 7 | Plant Fibers and Wood Products |
| 8 | A Foray into the Fungi |
| 9 | Herbs, Spices, Essential Oils, and Medicinal Plants |
| 10 | Poisonous and Psychoactive Plants |
| 11 | Stimulating Plant Beverages |
| 12 | Plants and the Environment |
| Type | Points | Percentage |
|---|---|---|
| 3 Exams | 200 each | 40% of final grade |
| 12 Lesson Assignments | 75 | 60% of final grade |
You will need to secure a proctor in order to take exams in this course. A proctor will not automatically be assigned to you; rather, you must make the necessary contacts to secure a professional who will serve in this capacity.


{% extends "base.html" %} {% block title %} Thank you for your letter {% endblock %} {% block content %}
Thank you for submitting your letter.
A GroundUp editor will make a decision whether to publish it or not within two working days.
If we publish the letter, it may be edited for typos, grammar and style. The title may also be changed.
We will communicate with you via the email address you provided.


Overview: Git and GitHub
Git can be described as a control system in local devices and you use Git to control the project.
GitHub is an online service for developers to store their projects (repositories), and it allows multiple developers to work on a project at the same time. Both Git and GitHub
feature different commands for developers to make collaborating more conveniently.
Why Git and GitHub?
In the past, if a team consists of 3 to 4 people worked on a same project, they would code
everything offline in their personal devices and then met up with each other to combine the codes, which had been proved to be insufficient and inconvenient at the same time.
Firstly, it might be challenging to find the right time for all team members to gather due to different timetables, and combining the codes in such a way is also time-consuming
and the potential of running into bug is really high. Additionally, it is impossible to evaluate the contribution of each team member to the source codes. Git and GitHub help to solve such issue.
How do they work?
First, one team member should create a repository to store all the source code of the project. Developers can pull the code from GitHub to work in their personal devices and push them up once
they had completed. Changes in the source code will be recorded, so in case the new codes do not run well, developers can instantly go back to the old version. Overall, Git and GitHub in combination make working in a project more effective for team members, as well as it
allows project leader to evaluate precisely the contribution that each member has on the project. Finally, GitHub saves all the work that an individual had contributed to different projects from
day one, which means the system would evaluate personal contribution after each project and give credit for such contribution. This can be a major factors nowadays to employers since it showcases
developers’ experience, which might be critical if they want to apply for a job or involve in any projects because employers need to know if an applicant had the right skills or qualifications that
they are looking for.