def main(): # Verify python version is >=3.5 # req_version is 3.5 due to usage of subprocess.run assert_version((3, 5)) if sys.platform.startswith("linux") and ("DISPLAY" not in os.environ or not os.environ["DISPLAY"]): raise Exception("DISPLAY environment variable not set") # Read settings from config config = load_config() args = parse_args(default_poll_time=config.getfloat("poll_time"), default_exclude_title=config.getboolean("exclude_title")) setup_logging(name="aw-watcher-window", testing=args.testing, verbose=args.verbose, log_stderr=True, log_file=True) client = ActivityWatchClient("aw-watcher-window", testing=args.testing) bucket_id = "{}_{}".format(client.client_name, client.client_hostname) event_type = "currentwindow" client.create_bucket(bucket_id, event_type, queued=True) logger.info("aw-watcher-window started") sleep(1) # wait for server to start with client: heartbeat_loop(client, bucket_id, poll_time=args.poll_time, exclude_title=args.exclude_title)
class Detector: def __init__(self) -> None: self.client = ActivityWatchClient("status-checker") # TODO: Move to aw-client? # TODO: Doesn't care if the event was old (as can happen if you have a dead watcher) def _get_last_event(self, bucket_id: str) -> Event: last_events = self.client.get_events(bucket_id, limit=1) if last_events: return last_events[0] else: raise Exception("no event found") def get_bucket_id(self, type: str) -> str: # TODO: Doesn't care about hostname # TODO (maybe): Create a better way to query buckets buckets = self.client.get_buckets() # print(buckets) window_bucket = find( lambda bucket: bucket["type"] == type and "testing" not in bucket[ "id"], buckets.values()) if window_bucket is None: raise Exception("Bucket not found") return window_bucket["id"] def detect(self, bucket_id: str, filter_str: str) -> Optional[Event]: last_event = self._get_last_event(bucket_id) return last_event if find(lambda label: filter_str in label.lower(), last_event.labels) else None
def main() -> None: now = datetime.now(tz=timezone.utc) td30d = timedelta(days=7) aw = ActivityWatchClient() print("Querying...") data = aw.query(_query, [(now - td30d, now)]) events = [{ "timestamp": e["timestamp"], "duration": timedelta(seconds=e["duration"]), **e["data"], } for e in data[0]["events"]] df = pd.json_normalize(events) df["timestamp"] = pd.to_datetime(df["timestamp"], infer_datetime_format=True) df.set_index("timestamp", inplace=True) print(df) answer = input("Do you want to export to CSV? (y/N): ") if answer == "y": filename = "output.csv" df.to_csv(filename) print(f"Wrote to {filename}")
def main(): import argparse parser = argparse.ArgumentParser("A watcher for ping") parser.add_argument("--testing", action="store_true") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG if args.testing else logging.INFO) client = ActivityWatchClient("aw-watcher-network", testing=args.testing) bucketname = "{}_{}".format(client.client_name, client.client_hostname) eventtype = "ping" client.create_bucket(bucketname, eventtype) logger.info("Starting to log ping") while True: t = datetime.utcnow() sleeptime = 60 - (t.second + t.microsecond/1000000.0) sleep(sleeptime) timestamp = datetime.now(pytz.utc) wifiname = Wireless().current() try: out = ping(30) client.send_events(bucketname, createEvents(out,timestamp,wifiname)) logger.info("Sent events") except Exception as e: import sys, traceback traceback.print_exc() logger.error("Exception thrown while pinging {}".format(e))
def __init__(self, testing=False): config_section = "aw-watcher-table" if not testing else "aw-watcher-table-testing" self.settings = Settings(watcher_config[config_section]) self.client = ActivityWatchClient("aw-watcher-table", testing=testing) self.bucket_id = "{}_{}".format(self.client.client_name, self.client.client_hostname)
def main(): # Verify python version is >=3.5 # req_version is 3.5 due to usage of subprocess.run assert_version((3, 5)) if sys.platform.startswith("linux") and ("DISPLAY" not in os.environ or not os.environ["DISPLAY"]): raise Exception("DISPLAY environment variable not set") # Read settings from config config = load_config() args = parse_args(default_poll_time=config.getfloat("poll_time")) setup_logging(name="aw-watcher-window", testing=args.testing, verbose=args.verbose, log_stderr=True, log_file=True) client = ActivityWatchClient("aw-watcher-window", testing=args.testing) bucket_id = "{}_{}".format(client.client_name, client.client_hostname) event_type = "currentwindow" client.create_bucket(bucket_id, event_type, queued=True) logger.info("aw-watcher-window started") sleep(1) # wait for server to start with client: heartbeat_loop(client, bucket_id, poll_time=args.poll_time, exclude_title=args.exclude_title)
def bucket_report(bucket_name,start_date,end_date): client = ActivityWatchClient("aw-watcher-cli", testing=False) bucket_id = "{}_{}".format(bucket_name, client.hostname) query = "RETURN = query_bucket('{}');".format(bucket_id) events = client.query(query,start_date,end_date)[0] if len(events) == 0: print("No events") exit() events.reverse() #oder from oldest to newest # first date date = parser.parse(events[0]["timestamp"],default=datetime.now()) - timedelta(hours=6) #- CST print(date.date()) #print first date day_duration = 0 total_duration = 0 cnt = 1 for event in events: total_duration += event["duration"] timestamp = parser.parse(event["timestamp"],default=datetime.now()) - timedelta(hours=6) #- CST if date.date() != timestamp.date(): date = timestamp print("sum:\t{}".format(format_duration(day_duration))) #duration from prev block print("") day_duration = event["duration"] #reset duration print(date.date()) #print next date else: day_duration += event["duration"] print("{}.\t{}\t{}".format(cnt,format_duration(event["duration"]),event["data"]["label"])) cnt += 1 #print last day_duration when last event is reached if event == events[-1]: print("sum:\t{}".format(format_duration(day_duration))) #Print total report duration print("total:\t{}".format(format_duration(total_duration)))
def __init__(self, testing=False, send_commands=True, send_heartbeats=True): # Create client self._client = ActivityWatchClient(client_id, testing=testing) self._client.connect() self._init_buckets() # Settings self.pulsetime = 10 self.send_commands = send_commands self.send_heartbeats = send_heartbeats # Initialize the EventQueue self._event_queue = EventQueue(callback=self._handle_event, time_buffer=(self.pulsetime / 2)) self._event_handlers = { 'preopen': self._preopen, 'preexec': self._preexec, 'precmd': self._precmd, 'preclose': self._preclose } self._terminal_sessions = {}
def __init__(self, testing=False): # Read settings from config configsection = "aw-watcher-afk" if not testing else "aw-watcher-afk-testing" self.settings = Settings(watcher_config[configsection]) self.client = ActivityWatchClient("aw-watcher-afk", testing=testing) self.bucketname = "{}_{}".format(self.client.client_name, self.client.client_hostname)
def __init__(self): self.aw_client = ActivityWatchClient() self.all_buckets = {} self.bucket = self._get_main_bucket() self.aw_watcher_window_id = self.bucket['id'] self._all_buckets_events = {}
def client(): c = ActivityWatchClient("client-test", testing=True) yield c # Delete test buckets after all tests needing the fixture have been run buckets = c.get_buckets() for bucket_id in buckets: if bucket_id.startswith("test-"): c.delete_bucket(bucket_id)
def __init__(self, poll_time: int = 5, timeout: int = 180) -> None: self.client = ActivityWatchClient("aw-watcher-afk", testing=False) self.bucketname = "{}_{}".format( self.client.client_name, self.client.client_hostname ) self.poll_time = poll_time self.timeout = timeout self.initiated_shutdown: bool = False
def windows_watcher_run() -> None: client = ActivityWatchClient("aw-watcher-window", testing=False) bucket_id = "{}_{}".format(client.client_name, client.client_hostname) event_type = "currentwindow" client.create_bucket(bucket_id, event_type, queued=True) sleep(1) # wait for server to start with client: heartbeat_loop(client, bucket_id, poll_time=2.0, exclude_title=False)
def shutdown(bucket_name,start_time,end_time,activity): client = ActivityWatchClient("aw-watcher-cli", testing=False) bucket_id = "{}_{}".format(bucket_name, client.hostname) event_type = "cli_activity" client.create_bucket(bucket_id, event_type=event_type) shutdown_data = {"label": activity} shutdown_event = Event(timestamp=start_time, data=shutdown_data, duration=(end_time -start_time)) inserted_event = client.insert_event(bucket_id, shutdown_event) rd = relativedelta.relativedelta (end_time, start_time) print("Spent {:02}:{:02}:{:02} doing {}:".format(rd.hours, rd.minutes, rd.seconds,activity))
def main(): import argparse poll_time = 1.0 parser = argparse.ArgumentParser("A watcher for windows in X11") parser.add_argument("--testing", action="store_true") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG if args.testing else logging.INFO) client = ActivityWatchClient("x11watcher", testing=args.testing) bucketname = "{}_{}".format(client.client_name, client.client_hostname) eventtype = "currentwindow" client.create_bucket(bucketname, eventtype) # get_only_active = True last_window = [] while True: try: # wids = xprop.get_window_ids() active_window_id = xprop.get_active_window_id() if active_window_id == "0x0": print("Failed to find active window, id found was 0x0") sleep(poll_time) continue # Always true, getting all windows currently not supported # if get_only_active: current_window = xprop.get_windows([active_window_id], active_window_id)[0] # else: # current_windows = get_windows(wids, active_window_id) """ if last_windows != current_windows: last_windows = current_windows print("Windows changed") client.send_event(Event(windows=last_windows, timestamp=datetime.now())) print(current_windows) """ if last_window != current_window: last_window = current_window print("Window changed") labels = ["title:" + current_window["name"]] labels.extend(["class:" + cls for cls in set(current_window["class"])]) client.send_event(bucketname, Event(label=labels, timestamp=datetime.now(pytz.utc))) print(current_window) except Exception as e: logger.error("Exception thrown while trying to get active window: {}".format(e)) traceback.print_exc(e) sleep(poll_time)
def test_filter_short(): # TODO: This was used in dev and does not work. awapi = ActivityWatchClient("cleaner", testing=True) events = awapi.get_events(BUCKET_WEB, limit=-1) filter_short(events, threshold=1) events = awapi.get_events(BUCKET_WINDOW, limit=-1) filter_short(events, threshold=1) events = awapi.get_events(BUCKET_AFK, limit=-1) filter_short(events, threshold=30)
def aw_client(): # TODO: Could it be possible to write a sisterclass of ActivityWatchClient # which calls aw_server.api directly? Would it be of use? Would add another # layer of integration tests that are actually more like unit tests. c = ActivityWatchClient("client-test", testing=True) yield c # Delete test buckets after all tests needing the fixture have been run buckets = c.get_buckets() for bucket_id in buckets: if bucket_id.startswith("test-"): c.delete_bucket(bucket_id)
def aw_client(): # TODO: Could it be possible to write a sisterclass of ActivityWatchClient # which calls aw_server.api directly? Would it be of use? Would add another # layer of integration tests that are actually more like unit tests. c = ActivityWatchClient("client-test", testing=True) yield c # Delete test buckets after all tests needing the fixture have been run buckets = c.get_buckets() for bucket_id in buckets: if bucket_id.startswith("test-"): c.delete_bucket(bucket_id)
def get_begin_time(bucket_name: str = BUCKET_NAME) -> datetime.datetime: client = ActivityWatchClient() buckets = client.get_buckets() selected_bucket = None for bucket in buckets.values(): if bucket["id"] == bucket_name + "_" + bucket["hostname"]: selected_bucket = bucket if selected_bucket is None: raise ValueError( f"bucket {bucket_name} does not exist, run project watcher") return datetime.datetime.fromisoformat(selected_bucket["created"]).replace( tzinfo=get_localzone(), hour=0, minute=0, second=0)
def test_filter_short(): # TODO: This was used in dev and does not work. awapi = ActivityWatchClient("cleaner", testing=True) events = awapi.get_events("aw-watcher-web-test", limit=-1) filter_short(events, threshold=1) events = awapi.get_events("aw-watcher-window-testing_erb-main2-arch", limit=-1) filter_short(events, threshold=1) events = awapi.get_events("aw-watcher-afk-testing_erb-main2-arch", limit=-1) filter_short(events, threshold=30)
def _get_window_events(n=1000): client = ActivityWatchClient("aw-analyser", testing=True) buckets = client.get_buckets() bucket_id = None for _bid in buckets.keys(): if "window" in _bid and "testing" not in _bid: bucket_id = _bid if bucket_id: return client.get_events(bucket_id, limit=n) else: print("Did not find bucket") return []
def get_events( hostname: str, since: datetime, end: datetime, include_smartertime="auto", include_toggl=None, testing: bool = False, ) -> List[Event]: awc = ActivityWatchClient("test", testing=testing) query = build_query(hostname) logger.debug(f"Query:\n{query}") result = awc.query(query, timeperiods=[(since, end)]) events = [Event(**e) for e in result[0]] if include_smartertime: events = union_no_overlap( events, _get_events_smartertime(since, filepath=include_smartertime)) events = sorted(events, key=lambda e: e.timestamp) if include_toggl: events = union_no_overlap( events, _get_events_toggl(since, filepath=include_toggl)) events = sorted(events, key=lambda e: e.timestamp) # Filter by time events = [ e for e in events if since.astimezone(timezone.utc) < e.timestamp and e.timestamp + e.duration < end.astimezone(timezone.utc) ] assert all(since.astimezone(timezone.utc) < e.timestamp for e in events) assert all(e.timestamp + e.duration < end.astimezone(timezone.utc) for e in events) # Filter out events without data (which sometimes happens for whatever reason) events = [e for e in events if e.data] for event in events: if "app" not in event.data: if "url" in event.data: event.data["app"] = urlparse(event.data["url"]).netloc else: print("Unexpected event: ", event) events = [e for e in events if e.data] return events
def main(): global DRYRUN if "--wet" in sys.argv: DRYRUN = False global aw aw = ActivityWatchClient(testing=True) buckets = aw.get_buckets() print("Buckets: ") print("\n".join([" - " + bid for bid in buckets.keys()]) + "\n") bid_to_redact = input( "In which bucket are the events you want to redact? (* for all): " ) assert bid_to_redact == "*" or bid_to_redact in buckets, "Not a valid option" regex_or_string = input( "Do you want to search by regex or string? (regex/string): " ) assert regex_or_string in ["regex", "string"], "Not a valid option" print("\nNOTE: Matching is not case sensitive!") pattern: Union[str, Pattern] if regex_or_string == "string": pattern = input("Enter a string indicating sensitive content: ").lower() else: pattern = re.compile( input("Enter a regex indicating sensitive content: ").lower() ) print("") if DRYRUN: print( "NOTE: Performing a dry run, no events will be modified. Run with --wet to modify events." ) else: print( "WARNING: Note that this performs an operation that cannot be undone. We strongly recommend that you backup/export your data before proceeding." ) input("Press ENTER to continue, or Ctrl-C to abort") if bid_to_redact == "*": for bucket_id in buckets.keys(): if bucket_id.startswith("aw-watcher-afk"): return _redact_bucket(bucket_id, pattern) else: _redact_bucket(bid_to_redact, pattern)
def get_activity( project: str, begin: Optional[datetime.datetime] = None, end: Optional[datetime.datetime] = None, activity_buckets: Sequence[str] = DEFAULT_ACTIVITY_BUCKETS ) -> Activity: if begin is None: begin = get_begin_time() if end is None: end = get_default_end_time() time_periods = [(begin, end)] client = ActivityWatchClient() query = _get_activity_query(project, activity_buckets) events: List[ActivityData] = client.query(query, time_periods) return Activity(events[0]['aw_watcher_window_events'])
def __init__(self, testing=False): # Read settings from config configsection = "aw-watcher-afk" if not testing else "aw-watcher-afk-testing" self.settings = Settings(watcher_config[configsection]) self.client = ActivityWatchClient("aw-watcher-afk", testing=testing) self.bucketname = "{}_{}".format(self.client.client_name, self.client.client_hostname)
def delete_prev_buckets(): logging.info("Deleting old buckets") client = ActivityWatchClient("aw-fake-client", testing=True) client.client_hostname = hostname client.connect() try: client.delete_bucket(window_bucket_name) except HTTPError: pass try: client.delete_bucket(afk_bucket_name) except HTTPError: pass
def setup_client(): logging.info("Setting up client") client = ActivityWatchClient("aw-fake-client", testing=True) client.client_hostname = hostname eventtype = "currentwindow" client.create_bucket(window_bucket_name, eventtype) eventtype = "afkstatus" client.create_bucket(afk_bucket_name, eventtype) client.connect() return client
def get_events(hostname: str, since: datetime, end: datetime, include_smartertime='auto', include_toggl=None) -> List[Event]: awc = ActivityWatchClient("test", testing=False) # print(query_complete) query = build_query(hostname) result = awc.query(query, start=since, end=end) events = [Event(**e) for e in result[0]] if include_smartertime: events = _union_no_overlap( events, _get_events_smartertime(since, filepath=include_smartertime)) events = sorted(events, key=lambda e: e.timestamp) if include_toggl: events = _union_no_overlap( events, _get_events_toggl(since, filepath=include_toggl)) events = sorted(events, key=lambda e: e.timestamp) # Filter by time events = [ e for e in events if since.astimezone(timezone.utc) < e.timestamp and e.timestamp + e.duration < end.astimezone(timezone.utc) ] assert all(since.astimezone(timezone.utc) < e.timestamp for e in events) assert all(e.timestamp + e.duration < end.astimezone(timezone.utc) for e in events) # Filter out events without data (which sometimes happens for whatever reason) events = [e for e in events if e.data] for event in events: if 'app' not in event.data: if 'url' in event.data: event.data['app'] = urlparse(event.data['url']).netloc else: print('Unexpected event: ', event) events = [e for e in events if e.data] return events
def end_current_event(start_ts, category, item, end_dt=None): start_dt = datetime.utcfromtimestamp(start_ts) if end_dt is None: end_dt = datetime.utcnow() app.logger.debug('Instantiating client (127.0.0.1:5600)') client = ActivityWatchClient( "aw-watcher-manual-flaskweb", host='127.0.0.1:5600' ) bucket_id = "{}_{}".format("aw-watcher-manual-flaskweb", client.hostname) app.logger.debug('Creating bucket: %s', bucket_id) client.create_bucket(bucket_id, event_type="currentwindow") t = 'manual: %s/%s' % (category, item) evt = Event( timestamp=start_dt, duration=(end_dt - start_dt).total_seconds(), data={'app': t, 'title': t, 'category': category, 'item': item} ) inserted_event = client.insert_event(bucket_id, evt) app.logger.info('Inserted event: %s', inserted_event)
def test_full(): now = datetime.now(timezone.utc) client_name = "aw-test-client" bucket_name = "test-bucket" bucket_etype = "test" # Test context manager with ActivityWatchClient(client_name, testing=True) as client: time.sleep(1) # Check that client name is set correctly assert client.client_name == client_name # Delete bucket before creating it, and handle error if it doesn't already exist try: client.delete_bucket(bucket_name) except HTTPError: pass # Create bucket client.create_bucket(bucket_name, bucket_etype) # Check bucket buckets = client.get_buckets() assert bucket_name in buckets assert bucket_name == buckets[bucket_name]["id"] assert bucket_etype == buckets[bucket_name]["type"] # Insert events e1 = create_unique_event() e2 = create_unique_event() e3 = create_unique_event() events = [e1, e2, e3] client.insert_events(bucket_name, events) # Get events fetched_events = client.get_events(bucket_name, limit=len(events)) # Assert events assert [(e.timestamp, e.duration, e.data) for e in fetched_events] == [ (e.timestamp, e.duration, e.data) for e in events ] # Check eventcount eventcount = client.get_eventcount(bucket_name) assert eventcount == len(events) result = client.query( f"RETURN = query_bucket('{bucket_name}');", timeperiods=[(now - timedelta(hours=1), now + timedelta(hours=1))], ) assert len(result) == 1 assert len(result[0]) == 3 # Delete bucket client.delete_bucket(bucket_name)
def all_active_webactivity(): """Returns activity during non-afk events or when tab is audible""" awapi = ActivityWatchClient("test", testing=True) start = datetime.now() - timedelta(days=7) tabevents = awapi.get_events("aw-watcher-web-chrome", start=start) afkevents = awapi.get_events("aw-watcher-afk_erb-laptop2-arch", start=start) afkevents_notafk = list( filter(lambda e: e.data["status"] == "not-afk", afkevents)) tabevents_audible = list( filter(lambda e: "audible" in e.data and e.data["audible"], tabevents)) # TODO: Implement merge # activeevents = merge(afkevents_notafk, tabevents_audible) # This isn't perfect, buggy when a notafk/audible events is contained by another activeevents = afkevents_notafk + tabevents_audible return filter_period_intersect(tabevents, activeevents)
def main(dryrun=True): # TODO: Use wordlist instead of argument sensitive_words = ["sensitive"] aw = ActivityWatchClient(testing=True) re_word = r'\b{}\b' buckets = aw.get_buckets() for bid in buckets.keys(): if "window" not in bid: continue print("Checking bucket: {}".format(bid)) events = aw.get_events(bid, limit=-1) old_matches = set() for event in events: for key, val in event.data.items(): if isinstance(val, str): matches = [re.findall(re_word.format(word), val.lower()) for word in sensitive_words] matches = set(sum(matches, [])) if matches: event.data[key] = "REDACTED" if val not in old_matches: print(f"{'(DRYRUN) ' if dryrun else ''} Matches: {matches}, redacting: {val}") old_matches.add(val) if not dryrun: aw.insert_event(bid, event)
def heartbeat(bucket_name,start_time,activity): client = ActivityWatchClient("aw-watcher-cli", testing=False) bucket_id = "{}_{}".format(bucket_name, client.hostname) event_type = "cli_ping" client.create_bucket(bucket_id, event_type=event_type) # Asynchronous loop with client: heartbeat_data = {"label": "heartbeat"} now = datetime.now(timezone.utc) heartbeat_event = Event(timestamp=now, data=heartbeat_data) sleeptime = 1 #Sending hearbeat until keyboard interrup second = 1 while(True): # The duration between the heartbeats will be less than pulsetime, so they will get merged. rd = relativedelta.relativedelta (now, start_time) print("Doing: {} for {:02}:{:02}:{:02}".format(activity,rd.hours, rd.minutes, rd.seconds),end="\r") client.heartbeat(bucket_id, heartbeat_event, pulsetime=sleeptime+1, queued=True) # Sleep a second until next heartbeat sleep(sleeptime) # Update timestamp for next heartbeat heartbeat_event.timestamp = datetime.now(timezone.utc) # update now now = heartbeat_event.timestamp second += 1
def main(): import argparse parser = argparse.ArgumentParser("A watcher for ping") parser.add_argument("--testing", action="store_true") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG if args.testing else logging.INFO) client = ActivityWatchClient("aw-watcher-network", testing=args.testing) bucketname = "{}_{}".format(client.client_name, client.client_hostname) eventtype = "ping" client.create_bucket(bucketname, eventtype) logger.info("Starting to log ping") while True: t = datetime.utcnow() sleeptime = 60 - (t.second + t.microsecond / 1000000.0) sleep(sleeptime) timestamp = datetime.now(pytz.utc) wifiname = Wireless().current() try: out = ping(30) client.send_events(bucketname, createEvents(out, timestamp, wifiname)) logger.info("Sent events") except Exception as e: import sys, traceback traceback.print_exc() logger.error("Exception thrown while pinging {}".format(e))
def main(): import argparse poll_time = 1.0 parser = argparse.ArgumentParser("A watcher for windows in X11") parser.add_argument("--testing", action="store_true") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG if args.testing else logging.INFO) client = ActivityWatchClient("x11watcher", testing=args.testing) bucketname = "{}_{}".format(client.client_name, client.client_hostname) eventtype = "currentwindow" client.create_bucket(bucketname, eventtype) # get_only_active = True last_window = [] while True: try: # wids = xprop.get_window_ids() active_window_id = xprop.get_active_window_id() if active_window_id == "0x0": print("Failed to find active window, id found was 0x0") sleep(poll_time) continue # Always true, getting all windows currently not supported # if get_only_active: current_window = xprop.get_windows([active_window_id], active_window_id)[0] # else: # current_windows = get_windows(wids, active_window_id) """ if last_windows != current_windows: last_windows = current_windows print("Windows changed") client.send_event(Event(windows=last_windows, timestamp=datetime.now())) print(current_windows) """ if last_window != current_window: last_window = current_window print("Window changed") labels = ["title:" + current_window["name"]] labels.extend( ["class:" + cls for cls in set(current_window["class"])]) client.send_event( bucketname, Event(label=labels, timestamp=datetime.now(pytz.utc))) print(current_window) except Exception as e: logger.error( "Exception thrown while trying to get active window: {}". format(e)) traceback.print_exc(e) sleep(poll_time)
def test_failqueue(): client_name = "aw-test-client-" + str(randint(0, 10000)) bucket_id = "test-bucket-" + str(randint(0, 10000)) bucket_etype = "test" input("Make sure aw-server isn't running, then press enter > ") client1 = ActivityWatchClient(client_name, testing=True) client1.create_bucket(bucket_id, bucket_etype, queued=True) print("Creating events") events = [create_unique_event() for _ in range(3)] for i, e in enumerate(events): e.timestamp += timedelta(seconds=i) client1.heartbeat(bucket_id, e, pulsetime=1, queued=True) print("Trying to send events (should fail)") with client1: time.sleep(1) input("Start aw-server with --testing, then press enter > ") client2 = ActivityWatchClient(client_name, testing=True) client2.create_bucket(bucket_id, bucket_etype, queued=True) # Here the previously queued events should be sent with client2: time.sleep(1) print("Getting events") recv_events = client2.get_events(bucket_id) print("Asserting latest event") pprint(recv_events) pprint(recv_events[0].data['label']) pprint(events[2].data['label']) assert recv_events[0].data['label'] == events[2].data['label']
#!/usr/bin/env python3 from time import sleep from datetime import datetime, timedelta, timezone from aw_core.models import Event from aw_client import ActivityWatchClient client = ActivityWatchClient("test-client", testing=True) now = datetime.now(timezone.utc) start = now query = "RETURN=0;" res = client.query(query, "1970-01-01", "2100-01-01") print(res) # Should print 0 bucket_id = "{}_{}".format("test-client-bucket", client.hostname) event_type = "dummydata" client.create_bucket(bucket_id, event_type="test") def insert_events(label: str, count: int): global now events = [] for i in range(count): e = Event(timestamp=now, duration=timedelta(seconds=1), data={"label": label}) events.append(e) now = now + timedelta(seconds=1) client.insert_events(bucket_id, events)
# Usage: # python3 test_continous_events.py aw-watcher-afk-testing_{hostname} # # Example: # python3 test_continous_events.py aw-watcher-afk-testing_erb-laptop-ubuntu import sys from datetime import timedelta from aw_client import ActivityWatchClient client = ActivityWatchClient("aw-watcher-afk-test", testing=True) print(client.get_buckets()) bucket_id = sys.argv[1] events = client.get_events(bucket_id) # For example "aw-watcher-afk-testing_erb-laptop-ubuntu" print("\n\n") last_event = None wrong_events = 0 for event in sorted(events, key=lambda e: e.timestamp): if last_event: # The diff is the gap between the two events, should be zero # In reality it is currently sometimes negative and almost always larger than 1s diff = (event.timestamp - last_event.timestamp) - last_event.duration print("{} at {}".format(event.label, event.timestamp)) print("Duration: {}".format(event.duration)) if not timedelta(seconds=1) > abs(diff):
#!/usr/bin/env python3 from time import sleep from datetime import datetime, timedelta, timezone from aw_core.models import Event from aw_client import ActivityWatchClient # We'll run with testing=True so we don't mess up any production instance. # Make sure you've started aw-server with the `--testing` flag as well. client = ActivityWatchClient("test-client", testing=True) # Make the bucket_id unique for both the client and host # The convention is to use client-name_hostname as bucket name, # but if you have multiple buckets in one client you can add a # suffix such as client-name-event-type or similar bucket_id = "{}_{}".format("test-client-bucket", client.hostname) # A short and descriptive event type name # Will be used by visualizers (such as aw-webui) to detect what type and format the events are in # Can for example be "currentwindow", "afkstatus", "ping" or "currentsong" event_type = "dummydata" # First we need a bucket to send events/heartbeats to. # If the bucket already exists aw-server will simply return 304 NOT MODIFIED, # so run this every time the clients starts up to verify that the bucket exists. # If the client was unable to connect to aw-server or something failed # during the creation of the bucket, an exception will be raised. client.create_bucket(bucket_id, event_type="test") # Asynchronous loop example with client:
#!/usr/bin/env python3 from datetime import datetime, timezone from aw_core.models import Event from aw_client import ActivityWatchClient # We'll run with testing=True so we don't mess up any production instance. # Make sure you've started aw-server with the `--testing` flag as well. client = ActivityWatchClient("test-client", testing=True) bucket_id = "{}_{}".format("test-client-bucket", client.hostname) client.create_bucket(bucket_id, event_type="dummydata") shutdown_data = {"label": "some interesting data"} now = datetime.now(timezone.utc) shutdown_event = Event(timestamp=now, data=shutdown_data) inserted_event = client.insert_event(bucket_id, shutdown_event) events = client.get_events(bucket_id=bucket_id, limit=1) print(events) # Should print a single event in a list client.delete_bucket(bucket_id)
class AFKWatcher: def __init__(self, testing=False): # Read settings from config configsection = "aw-watcher-afk" if not testing else "aw-watcher-afk-testing" self.settings = Settings(watcher_config[configsection]) self.client = ActivityWatchClient("aw-watcher-afk", testing=testing) self.bucketname = "{}_{}".format(self.client.client_name, self.client.client_hostname) def ping(self, afk: bool, timestamp: datetime, duration: float = 0): data = {"status": "afk" if afk else "not-afk"} e = Event(timestamp=timestamp, duration=duration, data=data) pulsetime = self.settings.timeout + self.settings.poll_time self.client.heartbeat(self.bucketname, e, pulsetime=pulsetime, queued=True) def run(self): logger.info("aw-watcher-afk started") # Initialization sleep(1) eventtype = "afkstatus" self.client.create_bucket(self.bucketname, eventtype, queued=True) # Start afk checking loop with self.client: self.heartbeat_loop() def heartbeat_loop(self): afk = False while True: try: if system in ["Darwin", "Linux"] and os.getppid() == 1: # TODO: This won't work with PyInstaller which starts a bootloader process which will become the parent. # There is a solution however. # See: https://github.com/ActivityWatch/aw-qt/issues/19#issuecomment-316741125 logger.info("afkwatcher stopped because parent process died") break now = datetime.now(timezone.utc) seconds_since_input = seconds_since_last_input() last_input = now - timedelta(seconds=seconds_since_input) logger.debug("Seconds since last input: {}".format(seconds_since_input)) # If no longer AFK if afk and seconds_since_input < self.settings.timeout: logger.info("No longer AFK") self.ping(afk, timestamp=last_input) afk = False self.ping(afk, timestamp=last_input) # If becomes AFK elif not afk and seconds_since_input >= self.settings.timeout: logger.info("Became AFK") self.ping(afk, timestamp=last_input) afk = True self.ping(afk, timestamp=last_input, duration=seconds_since_input) # Send a heartbeat if no state change was made else: if afk: self.ping(afk, timestamp=last_input, duration=seconds_since_input) else: self.ping(afk, timestamp=last_input) sleep(self.settings.poll_time) except KeyboardInterrupt: logger.info("aw-watcher-afk stopped by keyboard interrupt") break