leftoff 0.1.0__py3-none-any.whl

leftoff/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from leftoff!")

leftoff/__main__.py

@@ -0,0 +1,115 @@
+
+# engine
+from leftoff.core.dtypes import StatsType # stats type dict 
+from leftoff.core.parser import LeftOffParser  # main todo engine 
+from leftoff.core.stats import Stats # statics of task 
+from leftoff.core.cli import CLI # cli manger 
+# tui 
+from leftoff.tui.core import TuiApp # core tui app 
+# py libs
+from pathlib import Path # py path lib
+import argparse as cli # cli argument parser
+# json
+import json
+# sys
+import sys
+
+def create_base_json(root_dir : Path) -> None :
+
+    title : str = input("Enter the Title : ")
+    version : float = float(input("Enter your current version : "))
+    data : dict = {
+                "title" : title,
+                "version": version,
+                "mode" : {
+                    'feat'  : [],
+                    'issue' : [] 
+                }
+            }
+
+    file : Path = root_dir / "leftoff.json"
+    json.dump(data,file.open(mode='w'))
+
+# tui
+def show_tui(l_engine):
+    if l_engine.data['mode']['feat'] == [] and  l_engine.data['mode']['issue'] == []  :
+        print("There is no task to show")
+        return 
+    feat_stats = Stats(l_engine.get_feat_table())
+    issue_stats = Stats(l_engine.get_issue_table())
+    stats = StatsType(
+                      feat_count=feat_stats.get_count(),
+                      issue_count=issue_stats.get_count(),
+                      active=(feat_stats.get_active_count()[0] + issue_stats.get_active_count()[0]),
+                      compl=(feat_stats.get_active_count()[1] + issue_stats.get_active_count()[1])
+                  ) 
+    app = TuiApp(
+                  title=l_engine.get_title(),
+                  version=l_engine.get_version(),
+                  mode=None,
+                  feat_tabel=l_engine.get_feat_table(),
+                  issue_tabel=l_engine.get_issue_table(),
+                  stats=stats
+              )
+    app.run()
+
+def main() -> None :
+
+    
+    root_dir : Path = Path(".")
+    # if  leftover.json isnt in root everything falls apart
+    if not (root_dir / "leftoff.json").exists() :
+        create_base_json(root_dir)
+        print("\nGood Luck with project !!")
+        return
+
+    parser = cli.ArgumentParser(description="Todo cli also support tui")
+    parser.add_argument("--tui", action="store_true",help="show tui")
+    parser.add_argument("--mode",type=str,help="feature mode")
+    parser.add_argument("--add",type=str,help="add to task")
+    parser.add_argument("--mod",type=str,help="Change the task status")
+    parser.add_argument("--rm",type=int,help="Remove task")
+    args = parser.parse_args()
+
+    if len(sys.argv) == 1 :
+        print("To Know how to use it ? use ( --help )")
+        return 
+    
+    engine = LeftOffParser(root_dir)
+    cli_parser = CLI(engine)
+
+    if args.tui: show_tui(engine)
+
+    # cli 
+    
+    if args.mode == 'feat':
+        if args.add is not None :
+            cli_parser.add_task('feat',args.add)
+            print("New task is added on Feature !!")
+
+        if args.mod is not None :
+            mod_id = cli_parser.mod_task('feat',args.mod)
+            print(f"Task {mod_id} status is modifed")
+
+        if args.rm is not None :
+            cli_parser.rm_task('feat',task_id=args.rm)
+            print(f"Task {args.rm} is removed")
+
+    if args.mode == 'issue':
+        if args.add is not None :
+            cli_parser.add_task('issue',args.add)
+            print("New task is added on issue !!")
+
+        if args.mod is not None :
+
+            mod_id = cli_parser.mod_task('issue',args.mod)
+            print(f"Task {mod_id} status is modifed")
+
+        if args.rm is not None :
+            cli_parser.rm_task('issue',task_id=args.rm)
+            print(f"Task {args.rm} is removed")
+
+
+if __name__ == "__main__":
+
+    main()

leftoff/core/cli.py

@@ -0,0 +1,45 @@
+
+# engine
+from leftoff.core.parser import LeftOffParser
+from leftoff.core.input_val import clean_args
+# typing 
+from typing import Literal
+# py date and time lin 
+from datetime import datetime,timedelta
+
+
+class CLI:
+
+    def __init__(self, parser_engine : LeftOffParser) -> None:
+
+        self.engine =  parser_engine
+               
+    def add_task(self, mode : Literal['feat', 'issue'] , add_input_text : str) -> None :
+        vals : list = clean_args(add_input_text)
+        today = datetime.now().date()
+        mode_id : int = self.engine.get_feat_id if mode == 'feat' else self.engine.get_issue_id
+        self.engine.add_task(mode,[{
+                            "id" : mode_id + 1,
+                            "task" : vals[0],
+                            "status" : "TODO",
+                            "due" : (today + timedelta(days=int(vals[1]))).strftime("%d-%m-%Y")
+                        }])
+        self.engine.json_writer()
+
+    def mod_task(self, mode : Literal['feat','issue'], mod_input_text : str ) -> int:
+
+        vals : list = clean_args(mod_input_text)
+        
+        self.engine.mod_status(mode,
+                            task_id=int(vals[0]),
+                            status=vals[1]
+                        )
+        self.engine.json_writer()
+        return int(vals[0])
+
+    def rm_task(self, mode : Literal['feat', 'issue'], task_id : int ) -> None:
+
+        self.engine.rm_task(mode,task_id=task_id)
+
+        self.engine.json_writer()
+        

leftoff/core/dtypes.py

@@ -0,0 +1,53 @@
+from typing import TypedDict,Literal
+
+
+class Table(TypedDict):
+
+    id : int
+    task : str
+    status : Literal["TODO","FIXING","FIXED"] 
+    due : str #  deadline date as str  
+
+
+class TodoJson(TypedDict):
+    title : str
+    version : float
+    mode : dict[Literal["feat","issue"],list[Table]] 
+    
+'''
+{
+    "title" : "shatokens",
+    "version" : 0.1,
+    "mode" : {
+        "feat" : [
+            {
+                "id" : 1,
+                "task" : "add mult file reading",
+                "status" : false,
+                "due" : "12-08-2026" 
+            },
+            {...}
+        ],
+        "issue" : [
+            {
+                "id" : 1,
+                "task" : "fix the padding on encode function",
+                "status" : false,
+                "due" : "21-08-2026" 
+            }
+        ]
+    }
+        
+    
+}    
+''' 
+
+class  StatsType(TypedDict):
+
+    feat_count : int
+
+    issue_count : int
+
+    active : int
+
+    compl : int # complete task 

leftoff/core/input_val.py

@@ -0,0 +1,4 @@
+
+def clean_args(input_text : str ) -> list :
+
+    return [x.strip() for x in input_text.split(",")]

leftoff/core/parser.py

@@ -0,0 +1,78 @@
+from typing import Literal
+from pathlib import Path
+
+import json
+
+from leftoff.core.dtypes import TodoJson,Table,StatsType
+from leftoff.core.type_val import validate_todo,InvalidTodo
+
+class  LeftOffParser:
+
+    def __init__(self, root_dir : Path ) -> None :
+
+        self.root_dir : Path =  root_dir
+
+        self.todo_file : Path = root_dir / "leftoff.json"
+
+        if not self.todo_file.exists :
+            raise FileNotFoundError("todo file is not found")
+
+        self.data : TodoJson  = self.json_reader()
+        if not validate_todo(self.data):
+            raise InvalidTodo("Invalid todo.json format")
+        
+    def json_reader(self) -> TodoJson :
+        
+        data = json.load(self.todo_file.open(mode='r'))
+
+        return data
+
+    def json_writer(self) -> None:
+        json.dump(self.data,self.todo_file.open(mode="w"))
+
+    # reader
+    
+    def get_title(self) -> str : return self.data.get('title')
+
+    def get_version(self) -> float : return self.data.get("version")
+
+    def get_feat_table(self) -> list[Table] : return self.data['mode']['feat']
+
+    def  get_issue_table(self) -> list[Table] : return self.data['mode']['issue']
+
+    # utils
+    @property
+    def get_feat_id(self) -> int : return self.get_feat_table()[-1].get('id') if self.get_feat_table() != []  else  0
+    @property
+    def get_issue_id(self) -> int : return self.get_issue_table()[-1].get('id') if self.get_issue_table() != [] else 0
+
+    # writer
+
+    def add_task(self,mode : Literal['feat', 'issue'], task : list[Table]) -> None :
+
+        self.data['mode'][mode].extend(task)
+
+    def mod_status(self, mode : Literal['feat', 'issue'], task_id : int, status : Literal['FIXING', 'FIXED'] ) -> None :
+
+        tasks = self.data['mode'][mode]
+
+        task = next((x for x in tasks if x['id'] == task_id),None)
+
+        if task is not None : task['status'] = status
+
+    def rm_task(self, mode : Literal['feat', 'issue'], task_id: int ) -> None :
+
+        tasks = self.data['mode'][mode]
+
+        if tasks is None:
+            print("There is No task to delete")
+            return
+        
+        # re-build the tasks without detele one     
+        self.data['mode'][mode] = [
+            task for task in tasks if task['id'] != task_id
+        ]
+
+        # re-set task ids
+        for i,task in enumerate(self.data['mode'][mode],start=1) : task['id'] = i
+        

leftoff/core/stats.py

@@ -0,0 +1,26 @@
+
+from leftoff.core.dtypes import StatsType,Table
+
+class Stats:
+
+    def __init__(self, table_data : list[Table]) -> None :
+
+        self.table_data : list[Table] = table_data
+
+
+    def get_count(self) -> int : return len(self.table_data)
+
+    def get_active_count(self) -> tuple[int , int]:
+
+        ac_count : int = 0
+        comp_count : int = 0
+        
+        for task in self.table_data:
+            status : str = task.get('status')
+            if  status == 'TODO' or status == 'FIXING' : ac_count += 1
+            elif status == 'FIXED' : comp_count += 1 
+
+        return (ac_count,comp_count) 
+    
+
+            

leftoff/core/type_val.py

@@ -0,0 +1,43 @@
+from typing import Any
+
+
+class InvalidTodo(Exception):
+    pass
+
+
+def validate_task(task: Any) -> bool:
+    return (
+        isinstance(task, dict)
+        and isinstance(task.get("id"), int)
+        and isinstance(task.get("task"), str)
+        and isinstance(task.get("status"), str)
+        and isinstance(task.get("due"), str)
+    )
+
+
+def validate_todo(data: Any) -> bool:
+    if not isinstance(data, dict):
+        return False
+
+    if not isinstance(data.get("title"), str):
+        return False
+
+    if not isinstance(data.get("version"), (int, float)):
+        return False
+
+    mode = data.get("mode")
+
+    if not isinstance(mode, dict):
+        return False
+
+    for category, tasks in mode.items():
+        if not isinstance(category, str):
+            return False
+
+        if not isinstance(tasks, list):
+            return False
+
+        if not all(validate_task(task) for task in tasks):
+            return False
+
+    return True

leftoff/tui/core.py

@@ -0,0 +1,62 @@
+from textual.widgets import Header
+from textual.containers import Vertical,Horizontal
+from textual.app import App, ComposeResult
+from textual.widgets import Static
+from textual.containers import Container
+
+from leftoff.core.dtypes import Table,StatsType
+from leftoff.tui.table import GTable
+
+class TuiApp(App):
+    CSS_PATH = "tcss/core_tui.tcss"
+    
+    TITLE = "Todo CLI"
+
+    def __init__(self,title : str | None,
+                    version : float | None,
+                    mode : str | None,
+                    feat_tabel : list[Table],
+                    issue_tabel : list[Table],
+                    stats : StatsType
+              ) -> None:
+
+        super().__init__()
+        
+        if title : self.title = f"{title} | {version}V"
+        if mode : self.HEADER_MODE = mode
+
+        self.tabel_data_feat : list[Table] = feat_tabel
+        self.tabel_data_issue : list[Table] = issue_tabel
+        self.stats_data : StatsType = stats
+
+
+    def compose(self) -> ComposeResult:
+        # Header
+        yield Header(show_clock=False)
+
+        with Vertical(id="main") :            
+            # --- STATS --
+            with Container(id="stats-box"):
+                
+                yield Static("─ STATISTICS ─", id="stats-title")
+                with Horizontal(id="stats-row"):
+                    yield Static(f"Active: [{self.stats_data.get('active')}]", classes="stat stat-green")
+                    yield Static(f"Features: [{self.stats_data.get('feat_count')}]", classes="stat stat-blue")
+                    yield Static(f"Issues: [{self.stats_data.get('issue_count')}]", classes="stat stat-red")
+                    yield Static(f"Completed: [{self.stats_data.get('compl')}]", classes="stat stat-yellow")
+
+            # --- Tabel ----
+            with Container(id="tasks-box"):
+                yield Static("─ ACTIVE PROJECT TASKS ─", id="tasks-title")
+                with Horizontal(id="tables"):
+                    with Vertical(id="features-panel"):
+                        yield Static("[ FEATURES / WORKS ]", classes="panel-title")
+                        yield GTable(id="features-table",table_data=self.tabel_data_feat)
+                    with Vertical(id="issues-panel"):
+                        yield Static("[ ISSUES / FIXES ]", classes="panel-title")
+                        yield GTable(id="issues-table",table_data=self.tabel_data_issue)
+        
+
+    def on_mount(self) -> None:
+        self.query_one("#features-table", GTable).focus()
+

leftoff/tui/table.py

@@ -0,0 +1,44 @@
+from textual.widgets import DataTable
+from rich.text import Text
+
+from leftoff.core.dtypes import Table
+
+class GTable(DataTable):
+    ''' Genral Tabel Format  '''
+
+    
+    STATUS_STYLES = {
+        "TODO": "bold green",
+        "FIXED": "bold yellow",
+        "FIXING": "bold magenta",
+    }
+    
+    def __init__(self, table_data : list[Table], **kwargs) -> None :
+
+        super().__init__(**kwargs)
+
+        self.table_data : list[Table] = table_data
+
+
+    def on_mount(self) -> None :
+
+        self.cursor_type = "row"
+        self.zebra_stripes = False
+        
+        # adding cols of table 
+        self.add_column("ID",width=4)
+        self.add_column("TASK",width=30)
+        self.add_column("STATUS",width=10)
+        self.add_column("DUE",width=12)
+
+        # adding rows of  table
+        for item in self.table_data:
+            style = self.STATUS_STYLES.get(item["status"],"White")
+            self.add_row(
+                str(item["id"]),
+                item["task"],
+                Text(f"[{item['status']}]", style=style),
+                Text(item["due"], style="yellow"),
+                key=str(item["id"]),
+            )
+        self.move_cursor(row=0)

leftoff/tui/tcss/core_tui.tcss

@@ -0,0 +1,150 @@
+Screen {
+    background: #0a0a0a;
+    color: #c8c8c8;
+}
+
+Header {
+    background: #0a0a0a;
+    color: #e0e0e0;
+    text-style: bold;
+    dock: top;
+    height: 1;
+}
+
+#main {
+    layout: vertical;
+    height: 1fr;
+    padding: 0 1;
+}
+
+/* ========== STATISTICS ========== */
+#stats-box {
+    height: 4;
+    border: solid #3a3a3a;
+    background: #0a0a0a;
+}
+
+#stats-title {
+    text-align: center;
+    color: #909090;
+    height: 1;
+    width: 100%;
+}
+
+#stats-row {
+    height: 1;
+    layout: horizontal;
+    align: center middle;
+    padding: 0 1;
+}
+
+.stat {
+    width: 1fr;
+    text-align: center;
+    height: 1;
+}
+
+.stat-green  { color: #00ff66; }
+.stat-blue   { color: #00bfff; }
+.stat-red    { color: #ff5555; }
+.stat-yellow { color: #ffcc00; }
+
+/* ========== ACTIVE PROJECT TASKS ========== */
+#tasks-box {
+    height: 1fr;
+    border: solid #3a3a3a;
+    background: #0a0a0a;
+    margin-top: 0;
+}
+
+#tasks-title {
+    text-align: center;
+    color: #909090;
+    height: 1;
+    width: 100%;
+}
+
+#tables {
+    height: 1fr;
+    layout: horizontal;
+}
+
+ #features-panel, #issues-panel {
+     width: 1fr;
+     height: 1fr;
+     border: solid #2a2a2a;
+     background: #0a0a0a;
+ }
+
+ .panel-title {
+     text-align: center;
+     color: #d8d8d8;
+     background: #141414;
+     height: 1;
+     width: 100%;
+     text-style: bold;
+ }
+
+ DataTable {
+     height: 1fr;
+     background: #0a0a0a;
+     color: #c8c8c8;
+     scrollbar-size-vertical: 0;
+     scrollbar-size-horizontal: 0;
+ }
+
+ DataTable > .datatable--header {
+     background: #1a3a7a;
+     color: #ffffff;
+     text-style: bold;
+ }
+
+DataTable > .datatable--cursor {
+    background: #0d5a0d;
+    color: #ffffff;
+    text-style: bold;
+}
+
+DataTable > .datatable--hover {
+    background: #122212;
+}
+
+/* ========== COMMAND BAR ========== */
+#cmd-box {
+    height: 3;
+    border: solid #00aa88;
+    background: #0a0a0a;
+    margin: 0 1;
+    layout: horizontal;
+    align: left middle;
+    padding: 0 1;
+}
+
+#cmd-label {
+    color: #00ffaa;
+    width: auto;
+    padding-right: 1;
+}
+
+#cmd-input {
+    background: #0a0a0a;
+    color: #ffffff;
+    border: none;
+    width: 1fr;
+    padding: 0;
+}
+
+#cmd-input:focus {
+    border: none;
+    background: #0a0a0a;
+}
+
+/* ========== FOOTER ========== */
+#footer-bar {
+    dock: bottom;
+    height: 1;
+    background: #121212;
+    color: #808080;
+    text-align: center;
+    width: 100%;
+}

leftoff-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: leftoff
+Version: 0.1.0
+Summary: Cli tool for managing project works.
+Author: shaheen-coder
+Author-email: shaheen-coder <shaheenvsa@gmail.com>
+Requires-Dist: pytest>=9.1.1
+Requires-Dist: textual>=8.2.8
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+

leftoff-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+leftoff/__init__.py,sha256=FdXJ8CrnXAClJ52Ns6_4EvQFrS3DNip-9xS67xS9BvA,53
+leftoff/__main__.py,sha256=IQlp7whsrJMnXt4KsDTrnKjfn2UL_exCLJYHS_-t7cc,3712
+leftoff/core/cli.py,sha256=A_yCaY0TzWdHWpWSGHtukwoAbih2owcG5932yZ5hhhc,1482
+leftoff/core/dtypes.py,sha256=_I8ChdTJudJFp1xowMD7CgNRN7YLO1Uq-vTN1g2dy1o,974
+leftoff/core/input_val.py,sha256=PfxmWUbqB9X8SYRCduUdwyTBVqfQVf5lLvFms73yino,100
+leftoff/core/parser.py,sha256=FvxQvXDZ9tch31yYfmhdBIZrHs9N2MzDrlSK0NGNgCY,2369
+leftoff/core/stats.py,sha256=0FhcCsgjwOuPN3mzdUdzvs89mD5M4BG3igPj__FqLUQ,623
+leftoff/core/type_val.py,sha256=WJfXduq5M4as42-e0d88lg__xaJc5WYAaY9UiitSGOM,945
+leftoff/tui/core.py,sha256=H0B7316gxrXqwH8mzTUV_ViJlZKdUaeSX90dk3QjUF4,2493
+leftoff/tui/table.py,sha256=l6q0ZMQ4Bs3CepoXQsXfV41Ym9MwEP0olVt5x3mZ1pY,1180
+leftoff/tui/tcss/core_tui.tcss,sha256=qvZ5ci7PwujZQN6zKAaNYUpXLVDcENJ7nQbA1o8Mp7g,2371
+leftoff-0.1.0.dist-info/WHEEL,sha256=R1d3uUTbmXM1FHXH_itQashbrqrOSVj-hvBCpmkIIGE,81
+leftoff-0.1.0.dist-info/entry_points.txt,sha256=TLHnjw5pWHe-xm10QVn3XdgZPtNCfAygBk2peaqN3h4,51
+leftoff-0.1.0.dist-info/METADATA,sha256=eBZ-LlsGos5ISsR_Ialf0NNHrpWlEQ8ki7OL7xre_GI,294
+leftoff-0.1.0.dist-info/RECORD,,

leftoff-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.17
+Root-Is-Purelib: true
+Tag: py3-none-any

leftoff-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+leftoff = leftoff.__main__:main
+