ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter("%(levelname)s - %(message)s") ch.setFormatter(formatter) log.addHandler(ch) try: if options.force and options.offline: raise AssertionError('Force and offline modes are mutually ' 'exclusive') keymaze = None if not options.offline: keymaze = KeymazePort(log, options.port) elif options.sync: raise AssertionError('Cannot sync from device in offline mode') cache = KeymazeCache(log, options.storage, keymaze) info = cache.get_information() if options.info: print ' Device: %s' % info['name'] print ' Owner: %s' % info['user'] print ' S/N: %s' % info['serialnumber'] print '' device = cache.get_device(info['serialnumber']) tpcat = cache.get_trackpoint_catalog(device) if options.sync: reload_cache = False
class Keymaze(object): def __init__(self, dbpath=None, port=None, offline_mode=False): log = logging.getLogger("pykmaze") log.setLevel(logging.INFO) ch = logging.StreamHandler() ch.setLevel(logging.INFO) formatter = logging.Formatter("%(levelname)s - %(message)s") ch.setFormatter(formatter) log.addHandler(ch) self.log = log if port is None: serial_ports = get_available_serial_ports() if len(serial_ports) == 0: print "No serial port detected, going to offline mode" offline_mode = True else: print "Available serial port:" print serial_ports port = serial_ports[0] print "Taking %s" % port if dbpath is None: dbpath = self._get_default_dbpath() self.dbpath = dbpath if not offline_mode: self.set_online_mode(port) else: self.set_offline_mode() def set_offline_mode(self): self.init_keymaze(None) self.current_mode = "offline" def set_online_mode(self, port): keymaze_port = KeymazePort(self.log, port) self.init_keymaze(keymaze_port) self.current_mode = "online" def init_keymaze(self, keymaze_port): self.cache = KeymazeCache(self.log, self.dbpath, keymaze_port) info = self.cache.get_information() self.device = self.cache.get_device(info["serialnumber"]) self.tpcat = self.cache.get_trackpoint_catalog(self.device) def _get_default_dbpath(self): dbname = "pykmaze.sqlite" dbpath = "HOME" in os.environ and os.environ["HOME"] or "." if sys.platform.lower() in ("darwin"): dbpath = os.path.join(dbpath, "Library", "Application Support", "Pykmaze", dbname) else: dbpath = os.path.join(dbpath, ".pykmaze", dbname) return dbpath def print_info(self): print " Device: %s" % self.info["name"] print " Owner: %s" % self.info["user"] print " S/N: %s" % self.info["serialnumber"] print "" def sync(self): if self.current_mode == "offline": raise AssertionError("Cannot sync from device in offline mode") reload_cache = False for tp in self.tpcat: if None in (tp["altmin"], tp["altmax"]): self.log.info("Should load sync track %d from device" % (int(tp["id"]))) self.cache.get_trackpoints(self.device, tp) reload_cache = True if reload_cache: self.tpcat = self.cache.get_trackpoint_catalog(self.device) def show_catalog(self): show_trackpoints_catalog(self.tpcat) print "" def get_all_tracks(self): tracks = [tp["track"] for tp in self.tpcat] self.log.debug("Tracks %s" % tracks) return tracks def get_trackinfo_from_name(self, trackname): trackname = int(trackname) for tp in self.tpcat: if int(tp["id"]) == trackname: return tp raise AssertionError('Track "%s" does not exist' % trackname) def get_trackpoints(self, trackinfo): self.log.info("Recovering trackpoints for track %u" % trackinfo["id"]) tpoints = self.cache.get_trackpoints(self.device, trackinfo) return tpoints def get_trackinfo(self, track): return filter(lambda x: x["id"] == track["id"], self.tpcat)[0] def trim_trackpoints(self, track_info, tpoints, trim): trims = parse_trim(trim.split(",")) self.log.info("All points: %d" % len(tpoints)) tpoints = trim_trackpoints(track_info, tpoints, trims) self.log.info("Filtered points: %d" % len(tpoints)) return tpoints def export_track(self, track, filename, filetype, trim=None, prepend_datetime=False, zoffset=0, mode="default"): # filetype 'gpx', 'kmz' or 'km' if filetype not in ["kmz", "kml", "gpx"]: raise AssertionError("Unsupported filetype %s" % filetype) track_info = self.get_trackinfo(track) tpoints = self.get_trackpoints(track_info) if prepend_datetime: stime = time.localtime(track_info["start"]) filename = os.path.join( os.path.dirname(filename), time.strftime("%Y-%m-%d-%H-%M-%S-", stime) + os.path.basename(filename) ) is_km = filetype in ["kmz", "kml"] if is_km: from kml import KmlDoc if filetype == "gpx": from gpx import GpxDoc if trim: tpoints = trim_trackpoints(track_info, tpoints, trim) optpoints = optimize(tpoints, 0) self.log.info("Count: %u, opt: %u", len(tpoints), len(optpoints)) if is_km: kml = KmlDoc(os.path.splitext(os.path.basename(filename))[0]) kml.add_trackpoints(optpoints, int(zoffset), extrude="air" not in mode) if filetype == "kmz": import zipfile import cStringIO as StringIO out = StringIO.StringIO() kml.write(out) out.write("\n") z = zipfile.ZipFile(filename, "w", zipfile.ZIP_DEFLATED) z.writestr("doc.kml", out.getvalue()) if filetype == "kml": with open(filename, "wt") as out: kml.write(out) out.write("\n") if filetype == "gpx": gpx = GpxDoc(os.path.splitext(os.path.basename(filename))[0], track_info["start"]) gpx.add_trackpoints(optpoints, int(zoffset)) with open(filename, "wt") as out: gpx.write(out) out.write("\n") def export_all_tracks(self, basename, filetype): for track in self.get_all_tracks(): self.export_track(track, basename, filetype, prepend_datetime=True)
def init_keymaze(self, keymaze_port): self.cache = KeymazeCache(self.log, self.dbpath, keymaze_port) info = self.cache.get_information() self.device = self.cache.get_device(info["serialnumber"]) self.tpcat = self.cache.get_trackpoint_catalog(self.device)
ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter("%(levelname)s - %(message)s") ch.setFormatter(formatter) log.addHandler(ch) try: if options.force and options.offline: raise AssertionError('Force and offline modes are mutually ' 'exclusive') keymaze = None if not options.offline: keymaze = KeymazePort(log, options.port) elif options.sync: raise AssertionError('Cannot sync from device in offline mode') cache = KeymazeCache(log, options.storage, keymaze) info = cache.get_information() if options.info: print >> sys.stdout, ' Device: %s' % info['name'] print >> sys.stdout, ' Owner: %s' % info['user'] print >> sys.stdout, ' S/N: %s' % info['serialnumber'] print >> sys.stdout, '' device = cache.get_device(info['serialnumber']) tpcat = cache.get_trackpoint_catalog(device) if options.sync: reload_cache = False