Source Code for Module park.fitting.fitservice

  1  # This program is public domain 
  2  """ 
  3  Interface to the PARK fitting service. 
  4   
  5  *** WARNING *** This is a design sketch and is not presently used. 
  6   
  7  TODO: user and url need to be retrieved from a config file with defaults 
  8  """ 
  9   
 10 -class Client(object): 
 11      """ 
 12      Client-side view of the fitting service. 
 13      """ 
 14 -    def __init__(self, url=None,user=None): 
 15          self.url = url 
 16          self.user = user 
 17          self.server = xmlrpclib.Server(self.server) 
 18          self.context = self.server.welcome(self.user) 
 19   
 20      # User management 
 21 -    def notify(self,email=None,rate=None): 
 22          """Set the email address and update frequency for user notification""" 
 23          if email is not None: 
 24              self.server.setemail(self.context, email) 
 25          if rate is not None: 
 26              self.server.setrate(self.context, rate) 
 27   
 28      # Job management 
 29 -    def find_by_name(self, name): 
 30          return self.server.find_by_name(self.context,status) 
 31 -    def find_jobs(self,status='active'): 
 32          """List active and recently completed jobs""" 
 33          return self.server.find_jobs(self.context,status) 
 34 -    def stop(self, jobid): 
 35          """Delete job""" 
 36          self.server.delete(self.context, jobid) 
 37 -    def start(self, job): 
 38          s = encode(job) 
 39          return self.server.submit(self.context, jobname, job) 
 40 -    def fetch_job(self, jobid): 
 41          """Retrieve job""" 
 42          text = self.server.retrieve(self.context, jobid) 
 43          return encode(text) 
 44 -    def status(self, jobid): 
 45          """Return the current job status""" 
 46          return self.server.status(self.context, jobid) 
 47   
 48      # Message Queue 
 49 -    def _listener(self, callback): 
 50          while True: 
 51              message = self.server.next_message(self.user) 
 52              event,result = pickle.loads(text) 
 53              callback(event, self, result) 
 54   
 55 -    def listen(self, callback=on_message): 
 56          """ 
 57          Listen to the message queue for information about running jobs. 
 58   
 59          The listener runs in a separate thread, allowing the listen 
 60          call to return immediately.  The callback is called each time 
 61          there is a new message on the queue.  If no callback is 
 62          supplied, then a simple print is used. 
 63          """ 
 64          thread.start_new_thread(self._listener,(callback,)) 
 65   
 66   
 67   
 68 -class Fit(object): 
 69      """ 
 70      Coordinate the fit. 
 71      """ 
 72      update = on_fit_update 
 73      complete = on_fit_complete 
 74 -    def __init__(self, models = [], 
 75                   optimizer = None, 
 76                   service = None, 
 77                   update = None, 
 78                   complete = None): 
 79          """ 
 80          Set up the fit. 
 81   
 82          models [] 
 83             List of models which make up the assembly. 
 84          optimizer 
 85             Optimizer to use for the fit 
 86          """ 
 87          self.assembly = assembly.Assembly(models) 
 88          self.optimizer = optimizer 
 89          self.complete = complete 
 90          self.update = update 
 91          self.isrunning = False 
 92          self._stopping = False 
 93   
 94 -    def stop(self): 
 95          """ 
 96          Interrupt a running fit. 
 97          """ 
 98          self._stopping = True 
 99          self.service.stop() 
100   
101 -    def start(self): 
102          """ 
103          Start the fit. 
104          """ 
105          self.service.start() 
106   
107 -    def _update(self, result): 
108          self.result = result 
109          if self.update: self.update(self,result) 
110   
111 -    def _complete(self, result): 
112          self.result = result 
113          if self.complete: self.complete(self,result) 
114   
115 -    def wait(self): 
116          """ 
117          Wait for a fit to complete. 
118          """ 
119          while self.isrunning: time.sleep(0.1) 
120   
121 -    def fit(self): 
122          """ 
123          Start the fit and wait for the result. 
124          Returns the result. 
125          """ 
126          self.start() 
127          self.wait() 
128          return self.result 
129