keka-log 0.1.0__tar.gz

keka_log-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quid Keka Log contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

keka_log-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include keka_log/*.mp3

keka_log-0.1.0/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: keka-log
+Version: 0.1.0
+Summary: CLI and optional macOS menu bar app for Keka attendance tracking.
+Author: Quid Keka Log contributors
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/keka-log/
+Keywords: keka,attendance,time-tracking,macos,menubar
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: menubar
+Requires-Dist: rumps>=0.4.0; extra == "menubar"
+Dynamic: license-file
+
+# Keka Log
+
+A Python package for checking and tracking Keka attendance. Includes a CLI tool and a Mac menu bar app to keep track of your shift time.
+
+## Prerequisites & Configuration (`.zshrc`)
+
+Before using this tool, you need to extract your `KEKA_TOKEN` from your browser and configure it in your shell.
+
+### 1. Get your Keka Token
+1. Log in to your Keka portal in your web browser.
+2. Open Developer Tools (Inspect Element) -> **Network** tab.
+3. Refresh the page or navigate to the attendance section.
+4. Look for an API request (e.g., `summary` or `attendance`).
+5. Check the **Request Headers** for the `Authorization` header. It will look like `Bearer eyJ...`.
+6. Copy the long token string (everything after `Bearer `).
+
+### 2. Add to your `.zshrc`
+You need to configure the token and your preferred notification language in your shell configuration file (e.g., `~/.zshrc`).
+
+1. Open your `.zshrc` file in your terminal:
+   ```bash
+   nano ~/.zshrc
+   ```
+2. Add the following lines at the bottom of the file:
+   ```bash
+   # Keka Attendance App Configuration
+   export KEKA_TOKEN="paste_your_copied_token_here"
+   
+   # Optional: Set notification audio language ('hindi', 'telugu', or 'none')
+   # Defaults to 'hindi' if not set. Use 'none' to disable audio entirely.
+   export KEKA_LANGUAGE="telugu"
+   ```
+3. Save the file (in nano: `Ctrl+O`, `Enter`, `Ctrl+X`) and reload your configuration:
+   ```bash
+   source ~/.zshrc
+   ```
+
+## Installation
+
+### From PyPI (recommended)
+
+Install the CLI from [PyPI](https://pypi.org/project/keka-log/) (replace the version if you pin one):
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install keka-log
+```
+
+On **macOS**, install with the `menubar` extra so `keka-menubar` works (pulls in `rumps` and its dependencies):
+
+```bash
+pip install keka-log[menubar]
+```
+
+The base package has no third-party dependencies; only `keka-log[menubar]` adds the menu bar stack.
+
+### Without a virtual environment (direct install)
+
+Yes — you can install **normally** with `pip` into your user account or system Python, no `.venv` required.
+
+**CLI only:**
+
+```bash
+pip3 install keka-log
+```
+
+**macOS menu bar as well:**
+
+```bash
+pip3 install "keka-log[menubar]"
+```
+
+On **macOS with Homebrew Python** (and some Linux distros), plain `pip install` may be blocked with *externally-managed-environment*. In that case install into your user site-packages instead:
+
+```bash
+pip3 install --user "keka-log[menubar]"
+```
+
+Make sure your shell can find the scripts. User installs usually put executables under `~/.local/bin`. If `keka-log` is not found, add this to `~/.zshrc` and open a new terminal:
+
+```bash
+export PATH="$HOME/.local/bin:$PATH"
+```
+
+**Alternative — isolated apps without managing a venv yourself:** use [pipx](https://pypa.github.io/pipx/) (install with `brew install pipx` on macOS, then `pipx ensurepath`):
+
+```bash
+pipx install "keka-log[menubar]"
+```
+
+That installs the package in its own environment and puts `keka-log` / `keka-menubar` on your `PATH`.
+
+### From a local clone
+
+With a venv (good for development):
+
+```bash
+cd path/to/quid-keka-log
+python3 -m venv .venv
+source .venv/bin/activate
+pip install ".[menubar]"   # macOS: CLI + menubar
+# or
+pip install .              # CLI only (no rumps)
+```
+
+Or install directly from the folder without a venv:
+
+```bash
+cd path/to/quid-keka-log
+pip3 install --user ".[menubar]"
+```
+
+If you use a venv, run `source .venv/bin/activate` in each new terminal session where you want those commands.
+
+### Publishing a new release (maintainers)
+
+1. Bump `version` in `pyproject.toml` (and optionally `keka_log/__init__.py`).
+2. Build and upload to PyPI (use [API tokens](https://pypi.org/manage/account/token/), not your password):
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+For TestPyPI first:
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+Then install with:
+
+```bash
+pip install -i https://test.pypi.org/simple/ keka-log
+```
+
+## Usage
+
+If you installed inside a **virtual environment**, activate it first:
+
+```bash
+source .venv/bin/activate
+```
+
+If you installed with **`pip install --user`**, **`pipx`**, or a **system** `pip3 install`, you do not need a venv — open a normal terminal (ensure `~/.local/bin` is on your `PATH` if you used `--user`).
+
+### Run and stop commands
+
+| What | Run | Stop |
+|------|-----|------|
+| **CLI** (one-shot print) | `keka-log` | Nothing to stop — it exits after printing. |
+| **CLI** (refresh cache) | `keka-log refresh` | Same — exits when done. |
+| **Menu bar app** (stays running) | `keka-menubar` | See **Stopping the menu bar app** below. |
+
+**Stopping the menu bar app** (`keka-menubar` keeps running until you quit):
+
+1. **From the menu bar (recommended):** Click the Keka item in the top-right menu bar → **Quit**.
+2. **If you started it in a terminal** and that window is still open: focus that terminal and press **Ctrl+C**.
+3. **From another terminal** (if you closed the window or need to force-quit):
+
+   ```bash
+   pkill -f keka-menubar
+   ```
+
+   If nothing matches, list Python processes and stop the one running the app:
+
+   ```bash
+   ps aux | grep -i keka
+   kill <PID>
+   ```
+
+   Replace `<PID>` with the process id from the `ps` output.
+
+---
+
+### 1. CLI tool
+
+Print current attendance info, effective hours, and optimistic logout time:
+
+```bash
+keka-log
+```
+
+Refresh cached data from the Keka server:
+
+```bash
+keka-log refresh
+```
+
+### 2. Mac menu bar app (requires `pip install keka-log[menubar]`)
+
+Start the live countdown in the macOS menu bar:
+
+```bash
+keka-menubar
+```
+
+This shows a timer in the menu bar. When your shift is complete, it can play audio (unless `KEKA_LANGUAGE=none`) and show a notification. Use **Quit** in the menu or the stop commands above when you are done for the day.

keka_log-0.1.0/README.md

@@ -0,0 +1,200 @@
+# Keka Log
+
+A Python package for checking and tracking Keka attendance. Includes a CLI tool and a Mac menu bar app to keep track of your shift time.
+
+## Prerequisites & Configuration (`.zshrc`)
+
+Before using this tool, you need to extract your `KEKA_TOKEN` from your browser and configure it in your shell.
+
+### 1. Get your Keka Token
+1. Log in to your Keka portal in your web browser.
+2. Open Developer Tools (Inspect Element) -> **Network** tab.
+3. Refresh the page or navigate to the attendance section.
+4. Look for an API request (e.g., `summary` or `attendance`).
+5. Check the **Request Headers** for the `Authorization` header. It will look like `Bearer eyJ...`.
+6. Copy the long token string (everything after `Bearer `).
+
+### 2. Add to your `.zshrc`
+You need to configure the token and your preferred notification language in your shell configuration file (e.g., `~/.zshrc`).
+
+1. Open your `.zshrc` file in your terminal:
+   ```bash
+   nano ~/.zshrc
+   ```
+2. Add the following lines at the bottom of the file:
+   ```bash
+   # Keka Attendance App Configuration
+   export KEKA_TOKEN="paste_your_copied_token_here"
+   
+   # Optional: Set notification audio language ('hindi', 'telugu', or 'none')
+   # Defaults to 'hindi' if not set. Use 'none' to disable audio entirely.
+   export KEKA_LANGUAGE="telugu"
+   ```
+3. Save the file (in nano: `Ctrl+O`, `Enter`, `Ctrl+X`) and reload your configuration:
+   ```bash
+   source ~/.zshrc
+   ```
+
+## Installation
+
+### From PyPI (recommended)
+
+Install the CLI from [PyPI](https://pypi.org/project/keka-log/) (replace the version if you pin one):
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install keka-log
+```
+
+On **macOS**, install with the `menubar` extra so `keka-menubar` works (pulls in `rumps` and its dependencies):
+
+```bash
+pip install keka-log[menubar]
+```
+
+The base package has no third-party dependencies; only `keka-log[menubar]` adds the menu bar stack.
+
+### Without a virtual environment (direct install)
+
+Yes — you can install **normally** with `pip` into your user account or system Python, no `.venv` required.
+
+**CLI only:**
+
+```bash
+pip3 install keka-log
+```
+
+**macOS menu bar as well:**
+
+```bash
+pip3 install "keka-log[menubar]"
+```
+
+On **macOS with Homebrew Python** (and some Linux distros), plain `pip install` may be blocked with *externally-managed-environment*. In that case install into your user site-packages instead:
+
+```bash
+pip3 install --user "keka-log[menubar]"
+```
+
+Make sure your shell can find the scripts. User installs usually put executables under `~/.local/bin`. If `keka-log` is not found, add this to `~/.zshrc` and open a new terminal:
+
+```bash
+export PATH="$HOME/.local/bin:$PATH"
+```
+
+**Alternative — isolated apps without managing a venv yourself:** use [pipx](https://pypa.github.io/pipx/) (install with `brew install pipx` on macOS, then `pipx ensurepath`):
+
+```bash
+pipx install "keka-log[menubar]"
+```
+
+That installs the package in its own environment and puts `keka-log` / `keka-menubar` on your `PATH`.
+
+### From a local clone
+
+With a venv (good for development):
+
+```bash
+cd path/to/quid-keka-log
+python3 -m venv .venv
+source .venv/bin/activate
+pip install ".[menubar]"   # macOS: CLI + menubar
+# or
+pip install .              # CLI only (no rumps)
+```
+
+Or install directly from the folder without a venv:
+
+```bash
+cd path/to/quid-keka-log
+pip3 install --user ".[menubar]"
+```
+
+If you use a venv, run `source .venv/bin/activate` in each new terminal session where you want those commands.
+
+### Publishing a new release (maintainers)
+
+1. Bump `version` in `pyproject.toml` (and optionally `keka_log/__init__.py`).
+2. Build and upload to PyPI (use [API tokens](https://pypi.org/manage/account/token/), not your password):
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+For TestPyPI first:
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+Then install with:
+
+```bash
+pip install -i https://test.pypi.org/simple/ keka-log
+```
+
+## Usage
+
+If you installed inside a **virtual environment**, activate it first:
+
+```bash
+source .venv/bin/activate
+```
+
+If you installed with **`pip install --user`**, **`pipx`**, or a **system** `pip3 install`, you do not need a venv — open a normal terminal (ensure `~/.local/bin` is on your `PATH` if you used `--user`).
+
+### Run and stop commands
+
+| What | Run | Stop |
+|------|-----|------|
+| **CLI** (one-shot print) | `keka-log` | Nothing to stop — it exits after printing. |
+| **CLI** (refresh cache) | `keka-log refresh` | Same — exits when done. |
+| **Menu bar app** (stays running) | `keka-menubar` | See **Stopping the menu bar app** below. |
+
+**Stopping the menu bar app** (`keka-menubar` keeps running until you quit):
+
+1. **From the menu bar (recommended):** Click the Keka item in the top-right menu bar → **Quit**.
+2. **If you started it in a terminal** and that window is still open: focus that terminal and press **Ctrl+C**.
+3. **From another terminal** (if you closed the window or need to force-quit):
+
+   ```bash
+   pkill -f keka-menubar
+   ```
+
+   If nothing matches, list Python processes and stop the one running the app:
+
+   ```bash
+   ps aux | grep -i keka
+   kill <PID>
+   ```
+
+   Replace `<PID>` with the process id from the `ps` output.
+
+---
+
+### 1. CLI tool
+
+Print current attendance info, effective hours, and optimistic logout time:
+
+```bash
+keka-log
+```
+
+Refresh cached data from the Keka server:
+
+```bash
+keka-log refresh
+```
+
+### 2. Mac menu bar app (requires `pip install keka-log[menubar]`)
+
+Start the live countdown in the macOS menu bar:
+
+```bash
+keka-menubar
+```
+
+This shows a timer in the menu bar. When your shift is complete, it can play audio (unless `KEKA_LANGUAGE=none`) and show a notification. Use **Quit** in the menu or the stop commands above when you are done for the day.

keka_log-0.1.0/keka_log/__init__.py

@@ -0,0 +1,3 @@
+"""Keka Log Package."""
+
+__version__ = "0.1.0"

keka_log-0.1.0/keka_log/keka.py

@@ -0,0 +1,174 @@
+import os
+import sys
+import json
+import urllib.request
+import urllib.error
+from datetime import datetime, date
+
+# Gets the KEKA_TOKEN from environment variable
+KEKA_TOKEN = os.environ.get("KEKA_TOKEN")
+
+def get_cache_file():
+    cache_dir = os.environ.get("XDG_CACHE_HOME", os.path.join(os.path.expanduser("~"), ".cache"))
+    mlog_dir = os.path.join(cache_dir, "mlog")
+    os.makedirs(mlog_dir, exist_ok=True)
+    return os.path.join(mlog_dir, "keka_attendance.json")
+
+def to_seconds(time_str):
+    if isinstance(time_str, (int, float)):
+        return int(time_str * 3600 + 0.5)
+    
+    time_str = str(time_str).strip()
+    if ':' in time_str:
+        parts = time_str.split(':')
+        h = int(parts[0]) if len(parts) > 0 else 0
+        m = int(parts[1]) if len(parts) > 1 else 0
+        s = int(parts[2]) if len(parts) > 2 else 0
+        return h * 3600 + m * 60 + s
+    
+    try:
+        hours = float(time_str)
+        return int(hours * 3600 + 0.5)
+    except ValueError:
+        raise ValueError(f"unsupported duration format: {time_str}")
+
+def format_hms(total_seconds):
+    total_seconds = int(total_seconds)
+    hours = total_seconds // 3600
+    minutes = (total_seconds % 3600) // 60
+    seconds = total_seconds % 60
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+def parse_login_time(raw_timestamp):
+    if not raw_timestamp or raw_timestamp == "null":
+        raise ValueError("Invalid timestamp")
+        
+    try:
+        # Handle epoch time (Unix timestamp)
+        if isinstance(raw_timestamp, (int, float)) or str(raw_timestamp).isdigit():
+            epoch = int(raw_timestamp)
+            if epoch > 9999999999:  # milliseconds to seconds
+                epoch = epoch / 1000.0
+            return datetime.fromtimestamp(epoch).strftime("%H:%M:%S")
+            
+        # Handle ISO string
+        raw_timestamp = str(raw_timestamp)
+        # Simplistic ISO 8601 parsing 
+        raw_timestamp = raw_timestamp.replace('Z', '+00:00')
+        dt = datetime.fromisoformat(raw_timestamp)
+        # Convert to local time
+        dt = dt.astimezone()
+        return dt.strftime("%H:%M:%S")
+    except Exception as e:
+        raise ValueError(f"unable to parse login timestamp: {raw_timestamp}")
+
+def fetch_and_cache():
+    if not KEKA_TOKEN:
+        print("mlog: KEKA_TOKEN environment variable is not set", file=sys.stderr)
+        print("Please export KEKA_TOKEN or pass it inline before running the script.", file=sys.stderr)
+        sys.exit(1)
+        
+    url = "https://quid.keka.com/k/attendance/api/mytime/attendance/summary"
+    req = urllib.request.Request(url)
+    req.add_header("accept", "application/json, text/plain, */*")
+    req.add_header("authorization", f"Bearer {KEKA_TOKEN}")
+    
+    try:
+        with urllib.request.urlopen(req) as response:
+            data = json.loads(response.read().decode())
+    except urllib.error.URLError as e:
+        print(f"mlog: failed to fetch data from Keka API: {e}", file=sys.stderr)
+        sys.exit(1)
+        
+    try:
+        latest_data = data.get("data", [])[-1]
+        effective_hours = latest_data.get("totalEffectiveHours", 0)
+        
+        time_entries = latest_data.get("timeEntries", [])
+        if not time_entries:
+            raw_timestamp = None
+        else:
+            raw_timestamp = time_entries[-1]["actualTimestamp"]
+    except (KeyError, IndexError, TypeError):
+        print("mlog: unable to parse required fields from Keka response", file=sys.stderr)
+        sys.exit(1)
+        
+    last_login = parse_login_time(raw_timestamp) if raw_timestamp else None
+    cache_date = date.today().isoformat()
+    
+    cache_data = {
+        "cache_date": cache_date,
+        "effective_hours": effective_hours,
+        "last_login": last_login
+    }
+    
+    cache_file = get_cache_file()
+    with open(cache_file, "w") as f:
+        json.dump(cache_data, f)
+        
+    return cache_data
+
+def load_cached_or_fetch(action):
+    cache_file = get_cache_file()
+    cache_date = date.today().isoformat()
+    
+    if action == "refresh" or not os.path.exists(cache_file):
+        return fetch_and_cache()
+        
+    with open(cache_file, "r") as f:
+        try:
+            cache_data = json.load(f)
+        except json.JSONDecodeError:
+            return fetch_and_cache()
+            
+    # Invalidate cache if it's from a previous day or corrupted
+    if cache_data.get("cache_date") != cache_date or "effective_hours" not in cache_data or "last_login" not in cache_data:
+        return fetch_and_cache()
+        
+    return cache_data
+
+def mlog():
+    action = sys.argv[1] if len(sys.argv) > 1 else None
+    if action and action != "refresh":
+        print("Usage: python keka.py [refresh]", file=sys.stderr)
+        sys.exit(1)
+        
+    required_seconds = 27000 # 7.5 hours
+    
+    payload = load_cached_or_fetch(action)
+    cached_effective_hours = payload["effective_hours"]
+    last_login = payload.get("last_login")
+    
+    if not last_login:
+        print("No time entries logged for today yet.")
+        sys.exit(0)
+        
+    cached_effective_seconds = to_seconds(cached_effective_hours)
+    last_login_seconds = to_seconds(last_login)
+    
+    now = datetime.now()
+    now_seconds = now.hour * 3600 + now.minute * 60 + now.second
+    
+    # Time elapsed in the current session (since last login)
+    elapsed_seconds = now_seconds - last_login_seconds
+    if elapsed_seconds < 0:
+        elapsed_seconds += 86400
+        
+    dynamic_effective_seconds = cached_effective_seconds + elapsed_seconds
+    
+    if dynamic_effective_seconds >= required_seconds:
+        dynamic_remaining_seconds = 0
+        logout_seconds = now_seconds
+    else:
+        dynamic_remaining_seconds = required_seconds - dynamic_effective_seconds
+        logout_seconds = last_login_seconds + (required_seconds - cached_effective_seconds)
+        if logout_seconds >= 86400:
+            logout_seconds -= 86400
+            
+    print(f"Last login: {last_login}")
+    print(f"Effective hours: {format_hms(dynamic_effective_seconds)}")
+    print(f"Time remaining: {format_hms(dynamic_remaining_seconds)}")
+    print(f"Optimistic logout time: {format_hms(logout_seconds)}")
+
+if __name__ == "__main__":
+    mlog()

keka_log-0.1.0/keka_log/keka_menubar.py

@@ -0,0 +1,110 @@
+import rumps
+import sys
+import os
+from datetime import datetime
+from . import keka
+
+class KekaStatusBarApp(rumps.App):
+    def __init__(self):
+        super(KekaStatusBarApp, self).__init__("Keka: Loading...")
+        self.has_notified = False
+        
+        # We fetch the initial data once during startup
+        try:
+            self.payload = keka.load_cached_or_fetch(None)
+        except Exception as e:
+            self.title = "Keka: Error"
+            self.payload = None
+
+    @rumps.timer(1)
+    def update_clock(self, _):
+        if not self.payload:
+            return
+            
+        try:
+            cached_effective_hours = self.payload["effective_hours"]
+            last_login = self.payload.get("last_login")
+            
+            if not last_login:
+                self.title = "Keka: No logs today"
+                self.menu.clear()
+                refresh_btn = rumps.MenuItem("Refresh from Server")
+                refresh_btn.set_callback(self.manual_refresh)
+                self.menu.add(refresh_btn)
+                self.menu.add(rumps.MenuItem("Quit", callback=rumps.quit_application))
+                return
+                
+            cached_effective_seconds = keka.to_seconds(cached_effective_hours)
+            last_login_seconds = keka.to_seconds(last_login)
+            
+            now = datetime.now()
+            now_seconds = now.hour * 3600 + now.minute * 60 + now.second
+            
+            elapsed_seconds = now_seconds - last_login_seconds
+            if elapsed_seconds < 0:
+                elapsed_seconds += 86400
+                
+            dynamic_effective_seconds = cached_effective_seconds + elapsed_seconds
+            required_seconds = 27000 # 7.5 hours
+            
+            if dynamic_effective_seconds >= required_seconds:
+                dynamic_remaining_seconds = 0
+                logout_seconds = now_seconds
+                self.title = f"✅ Keka: Done!"
+                
+                # Send a notification if we haven't already
+                if not self.has_notified:
+                    os.system('''osascript -e 'display notification "You have completed your 7.5 hours for today." with title "Keka Shift Complete! 🎉" sound name "Glass"' ''')
+
+                    # Determine which audio to play based on language preference
+                    language = os.environ.get("KEKA_LANGUAGE", "hindi").lower()
+                    
+                    if language != "none":
+                        if language == "telugu":
+                            mp3_filename = "Orey Ajaamu Lagettaroy.mp3"
+                        else:
+                            mp3_filename = "are_tu_jaa_re.mp3"
+    
+                        # Use absolute path and quotes to handle spaces in the filename
+                        mp3_path = os.path.join(os.path.dirname(__file__), mp3_filename)
+                        os.system(f"afplay '{mp3_path}' &")
+                        
+                    self.has_notified = True
+            else:
+                self.has_notified = False # reset if somehow they go back under
+                dynamic_remaining_seconds = required_seconds - dynamic_effective_seconds
+                logout_seconds = last_login_seconds + (required_seconds - cached_effective_seconds)
+                if logout_seconds >= 86400:
+                    logout_seconds -= 86400
+                    
+                self.title = f"⏳ {keka.format_hms(dynamic_remaining_seconds)} "
+                
+            # Update the dropdown menu with the specific details
+            self.menu.clear()
+            self.menu.add(rumps.MenuItem(f"Logged in at: {last_login}"))
+            self.menu.add(rumps.MenuItem(f"Logout time: {keka.format_hms(logout_seconds)}"))
+            self.menu.add(rumps.MenuItem(f"Effective so far: {keka.format_hms(dynamic_effective_seconds)}"))
+            self.menu.add(rumps.separator)
+            
+            refresh_btn = rumps.MenuItem("Refresh from Server")
+            refresh_btn.set_callback(self.manual_refresh)
+            self.menu.add(refresh_btn)
+            
+            self.menu.add(rumps.MenuItem("Quit", callback=rumps.quit_application))
+            
+        except Exception as e:
+            self.title = "Keka: Error"
+
+    def manual_refresh(self, _):
+        self.title = "Keka: Refreshing..."
+        try:
+            self.payload = keka.load_cached_or_fetch("refresh")
+            self.update_clock(None)
+        except Exception as e:
+            self.title = "Keka: Auth Error"
+
+def main():
+    KekaStatusBarApp().run()
+
+if __name__ == "__main__":
+    main()

keka_log-0.1.0/keka_log/menubar_entry.py

@@ -0,0 +1,18 @@
+"""Console entry for keka-menubar; imports rumps before loading the menubar app."""
+
+import sys
+
+
+def main():
+    try:
+        import rumps  # noqa: F401
+    except ImportError:
+        print(
+            "keka-menubar needs optional dependencies. On macOS install with:\n"
+            "  pip install keka-log[menubar]",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    from keka_log.keka_menubar import main as run
+
+    run()

keka_log-0.1.0/keka_log.egg-info/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: keka-log
+Version: 0.1.0
+Summary: CLI and optional macOS menu bar app for Keka attendance tracking.
+Author: Quid Keka Log contributors
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/keka-log/
+Keywords: keka,attendance,time-tracking,macos,menubar
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: menubar
+Requires-Dist: rumps>=0.4.0; extra == "menubar"
+Dynamic: license-file
+
+# Keka Log
+
+A Python package for checking and tracking Keka attendance. Includes a CLI tool and a Mac menu bar app to keep track of your shift time.
+
+## Prerequisites & Configuration (`.zshrc`)
+
+Before using this tool, you need to extract your `KEKA_TOKEN` from your browser and configure it in your shell.
+
+### 1. Get your Keka Token
+1. Log in to your Keka portal in your web browser.
+2. Open Developer Tools (Inspect Element) -> **Network** tab.
+3. Refresh the page or navigate to the attendance section.
+4. Look for an API request (e.g., `summary` or `attendance`).
+5. Check the **Request Headers** for the `Authorization` header. It will look like `Bearer eyJ...`.
+6. Copy the long token string (everything after `Bearer `).
+
+### 2. Add to your `.zshrc`
+You need to configure the token and your preferred notification language in your shell configuration file (e.g., `~/.zshrc`).
+
+1. Open your `.zshrc` file in your terminal:
+   ```bash
+   nano ~/.zshrc
+   ```
+2. Add the following lines at the bottom of the file:
+   ```bash
+   # Keka Attendance App Configuration
+   export KEKA_TOKEN="paste_your_copied_token_here"
+   
+   # Optional: Set notification audio language ('hindi', 'telugu', or 'none')
+   # Defaults to 'hindi' if not set. Use 'none' to disable audio entirely.
+   export KEKA_LANGUAGE="telugu"
+   ```
+3. Save the file (in nano: `Ctrl+O`, `Enter`, `Ctrl+X`) and reload your configuration:
+   ```bash
+   source ~/.zshrc
+   ```
+
+## Installation
+
+### From PyPI (recommended)
+
+Install the CLI from [PyPI](https://pypi.org/project/keka-log/) (replace the version if you pin one):
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install keka-log
+```
+
+On **macOS**, install with the `menubar` extra so `keka-menubar` works (pulls in `rumps` and its dependencies):
+
+```bash
+pip install keka-log[menubar]
+```
+
+The base package has no third-party dependencies; only `keka-log[menubar]` adds the menu bar stack.
+
+### Without a virtual environment (direct install)
+
+Yes — you can install **normally** with `pip` into your user account or system Python, no `.venv` required.
+
+**CLI only:**
+
+```bash
+pip3 install keka-log
+```
+
+**macOS menu bar as well:**
+
+```bash
+pip3 install "keka-log[menubar]"
+```
+
+On **macOS with Homebrew Python** (and some Linux distros), plain `pip install` may be blocked with *externally-managed-environment*. In that case install into your user site-packages instead:
+
+```bash
+pip3 install --user "keka-log[menubar]"
+```
+
+Make sure your shell can find the scripts. User installs usually put executables under `~/.local/bin`. If `keka-log` is not found, add this to `~/.zshrc` and open a new terminal:
+
+```bash
+export PATH="$HOME/.local/bin:$PATH"
+```
+
+**Alternative — isolated apps without managing a venv yourself:** use [pipx](https://pypa.github.io/pipx/) (install with `brew install pipx` on macOS, then `pipx ensurepath`):
+
+```bash
+pipx install "keka-log[menubar]"
+```
+
+That installs the package in its own environment and puts `keka-log` / `keka-menubar` on your `PATH`.
+
+### From a local clone
+
+With a venv (good for development):
+
+```bash
+cd path/to/quid-keka-log
+python3 -m venv .venv
+source .venv/bin/activate
+pip install ".[menubar]"   # macOS: CLI + menubar
+# or
+pip install .              # CLI only (no rumps)
+```
+
+Or install directly from the folder without a venv:
+
+```bash
+cd path/to/quid-keka-log
+pip3 install --user ".[menubar]"
+```
+
+If you use a venv, run `source .venv/bin/activate` in each new terminal session where you want those commands.
+
+### Publishing a new release (maintainers)
+
+1. Bump `version` in `pyproject.toml` (and optionally `keka_log/__init__.py`).
+2. Build and upload to PyPI (use [API tokens](https://pypi.org/manage/account/token/), not your password):
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+For TestPyPI first:
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+Then install with:
+
+```bash
+pip install -i https://test.pypi.org/simple/ keka-log
+```
+
+## Usage
+
+If you installed inside a **virtual environment**, activate it first:
+
+```bash
+source .venv/bin/activate
+```
+
+If you installed with **`pip install --user`**, **`pipx`**, or a **system** `pip3 install`, you do not need a venv — open a normal terminal (ensure `~/.local/bin` is on your `PATH` if you used `--user`).
+
+### Run and stop commands
+
+| What | Run | Stop |
+|------|-----|------|
+| **CLI** (one-shot print) | `keka-log` | Nothing to stop — it exits after printing. |
+| **CLI** (refresh cache) | `keka-log refresh` | Same — exits when done. |
+| **Menu bar app** (stays running) | `keka-menubar` | See **Stopping the menu bar app** below. |
+
+**Stopping the menu bar app** (`keka-menubar` keeps running until you quit):
+
+1. **From the menu bar (recommended):** Click the Keka item in the top-right menu bar → **Quit**.
+2. **If you started it in a terminal** and that window is still open: focus that terminal and press **Ctrl+C**.
+3. **From another terminal** (if you closed the window or need to force-quit):
+
+   ```bash
+   pkill -f keka-menubar
+   ```
+
+   If nothing matches, list Python processes and stop the one running the app:
+
+   ```bash
+   ps aux | grep -i keka
+   kill <PID>
+   ```
+
+   Replace `<PID>` with the process id from the `ps` output.
+
+---
+
+### 1. CLI tool
+
+Print current attendance info, effective hours, and optimistic logout time:
+
+```bash
+keka-log
+```
+
+Refresh cached data from the Keka server:
+
+```bash
+keka-log refresh
+```
+
+### 2. Mac menu bar app (requires `pip install keka-log[menubar]`)
+
+Start the live countdown in the macOS menu bar:
+
+```bash
+keka-menubar
+```
+
+This shows a timer in the menu bar. When your shift is complete, it can play audio (unless `KEKA_LANGUAGE=none`) and show a notification. Use **Quit** in the menu or the stop commands above when you are done for the day.

keka_log-0.1.0/keka_log.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+keka_log/Orey Ajaamu Lagettaroy.mp3
+keka_log/__init__.py
+keka_log/are_tu_jaa_re.mp3
+keka_log/keka.py
+keka_log/keka_menubar.py
+keka_log/menubar_entry.py
+keka_log.egg-info/PKG-INFO
+keka_log.egg-info/SOURCES.txt
+keka_log.egg-info/dependency_links.txt
+keka_log.egg-info/entry_points.txt
+keka_log.egg-info/requires.txt
+keka_log.egg-info/top_level.txt

keka_log-0.1.0/keka_log.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

keka_log-0.1.0/keka_log.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+keka-log = keka_log.keka:mlog
+keka-menubar = keka_log.menubar_entry:main

keka_log-0.1.0/keka_log.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[menubar]
+rumps>=0.4.0

keka_log-0.1.0/keka_log.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+build
+dist
+keka_log

keka_log-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "keka-log"
+version = "0.1.0"
+description = "CLI and optional macOS menu bar app for Keka attendance tracking."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.8"
+authors = [
+    { name = "Quid Keka Log contributors" },
+]
+keywords = ["keka", "attendance", "time-tracking", "macos", "menubar"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: MacOS X",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: MacOS :: MacOS X",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business",
+]
+
+dependencies = []
+
+[project.optional-dependencies]
+menubar = [
+    "rumps>=0.4.0",
+]
+
+[project.urls]
+Homepage = "https://pypi.org/project/keka-log/"
+
+[project.scripts]
+keka-log = "keka_log.keka:mlog"
+keka-menubar = "keka_log.menubar_entry:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[tool.setuptools.package-data]
+keka_log = ["*.mp3"]

keka_log-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+